From 6ffcf60c1c32c28f71fb45fd6eaa7fb50657d076 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 25 Sep 2025 14:14:42 +0800
Subject: [PATCH 01/88] try to enable auto_scheme API

---
 auto_round/__init__.py              |  3 +-
 auto_round/__main__.py              |  9 ++++
 auto_round/auto_schemes/__init__.py | 24 +++++++++
 auto_round/autoround.py             |  5 +-
 auto_round/compressors/base.py      | 76 +++++++++++++++--------------
 auto_round/data_type/register.py    |  3 +-
 auto_round/schemes.py               | 29 +++++++++--
 7 files changed, 103 insertions(+), 46 deletions(-)
 create mode 100644 auto_round/auto_schemes/__init__.py

diff --git a/auto_round/__init__.py b/auto_round/__init__.py
index 15bbc373d..1ce7d5e1e 100644
--- a/auto_round/__init__.py
+++ b/auto_round/__init__.py
@@ -13,11 +13,10 @@
 # limitations under the License.
 from auto_round.autoround import AutoRound
 
-# support for old api
 from auto_round.autoround import AutoRoundLLM, AutoRoundMLLM, AutoRoundAdam
+from auto_round.schemes import QuantizationScheme, AutoScheme
 from auto_round.utils import LazyImport
 
-
 def __getattr__(name):
     if name == "AutoHfQuantizer":
         from auto_round.inference.auto_quantizer import AutoHfQuantizer
diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 78a8fc9d6..5c77c2f10 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -466,6 +466,13 @@ def tune(args):
     extra_config.tuning_config = tuning_config
     extra_config.scheme_config = scheme_config
     extra_config.mllm_config = mllm_config
+    layer_config = {}
+    from auto_round.auto_schemes.delta_loss import get_mixed_config_layer_config
+    best_path = get_mixed_config_layer_config(model_name,target_bits=6)
+    for item in best_path:
+        layer_config[item[0]] = {}
+        layer_config[item[0]]["bits"] = item[1]
+        layer_config[item[0]]["act_bits"] = item[1]
 
     autoround: BaseCompressor = AutoRound(
         model=model_name,
@@ -484,6 +491,8 @@ def tune(args):
         not_use_best_mse=args.not_use_best_mse,
         enable_adam=args.adam,
         extra_config=extra_config,
+        layer_config=layer_config
+
     )
 
     model_name = args.model.rstrip("/")
diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
new file mode 100644
index 000000000..38d40e023
--- /dev/null
+++ b/auto_round/auto_schemes/__init__.py
@@ -0,0 +1,24 @@
+AUTO_SCHEMES_ALGS = {}
+
+def register_dtype(names):
+    """Class decorator to register a mixed precision algorithm to the registry.
+
+    Decorator function used before a Pattern subclass.
+
+    Args:
+        names: A string. Define the export type.
+
+    Returns:
+        cls: The class of register.
+    """
+
+    def register(alg):
+        if isinstance(names, (tuple, list)):
+            for name in names:
+                AUTO_SCHEMES_ALGS[name] = alg
+        else:
+            AUTO_SCHEMES_ALGS[names] = alg
+
+        return alg
+
+    return register
diff --git a/auto_round/autoround.py b/auto_round/autoround.py
index 4074213a9..22d3dc29b 100644
--- a/auto_round/autoround.py
+++ b/auto_round/autoround.py
@@ -25,7 +25,7 @@
     MLLMCompressor,
 )
 from auto_round.logger import deprecated, logger
-from auto_round.schemes import QuantizationScheme
+from auto_round.schemes import QuantizationScheme, AutoScheme
 from auto_round.utils import is_mllm_model
 
 
@@ -64,6 +64,7 @@ def __new__(
         model: Union[torch.nn.Module, str],
         tokenizer=None,
         scheme: Union[str, dict, QuantizationScheme] = "W4A16",
+        auto_scheme: AutoScheme = None,
         layer_config: dict[str, Union[str, dict, QuantizationScheme]] = None,
         dataset: Union[str, list, tuple, torch.utils.data.DataLoader] = "NeelNanda/pile-10k",
         iters: int = 200,
@@ -77,7 +78,6 @@ def __new__(
         seed: int = 42,
         # for adam
         enable_adam: bool = False,
-        # for MLLM
         extra_config: ExtraConfig = None,
         **kwargs,
     ) -> BaseCompressor:
@@ -159,6 +159,7 @@ def __new__(
             model=model,
             tokenizer=tokenizer,
             scheme=scheme,
+            auto_scheme=auto_scheme,
             layer_config=layer_config,
             dataset=dataset,
             iters=iters,
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 01546034d..fa7ee0bf8 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -35,7 +35,7 @@
 from auto_round.export.export_to_gguf.config import GGUF_CONFIG, GGUF_INNER_CONFIG, ModelType
 from auto_round.logger import logger
 from auto_round.low_cpu_mem.utils import get_layers_before_block
-from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
+from auto_round.schemes import QuantizationScheme, preset_name_to_scheme, AutoScheme
 from auto_round.sign_sgd import SignSGD
 from auto_round.special_model_handler import _handle_moe_model
 from auto_round.utils import (
@@ -130,6 +130,7 @@ def __init__(
         model: Union[torch.nn.Module, str],
         tokenizer=None,
         scheme: Union[str, dict, QuantizationScheme] = "W4A16",
+        auto_scheme: AutoScheme = None,
         layer_config: dict[str, Union[str, dict, QuantizationScheme]] = None,
         dataset: Union[str, list, tuple, torch.utils.data.DataLoader] = "NeelNanda/pile-10k",
         iters: int = 200,
@@ -204,7 +205,6 @@ def __init__(
         """
         self.scheme = None
         self._parse_and_set_scheme(scheme, kwargs)
-
         # Extra/legacy kwargs for backward compatibility
         # Major version releases may pack them with extra configuration options
         amp = kwargs.pop("amp", True)
@@ -237,7 +237,7 @@ def __init__(
             logger.warning(f"unrecognized keys {list(kwargs.keys())} were passed. Please check them.")
         if "CUBLAS_WORKSPACE_CONFIG" not in os.environ:
             os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
-        # deprecated, default not to use torch.use_deterministic_algorithms
+        # Deprecated, default not to use torch.use_deterministic_algorithms
         if not disable_deterministic_algorithms or enable_deterministic_algorithms:
             if not disable_deterministic_algorithms:
                 logger.warning(
@@ -255,26 +255,14 @@ def __init__(
         if device_map is None:
             device_map = 0
 
-        # Set device, must place after model loading
-        self._set_device(device_map)
-
-        if (isinstance(device_map, dict) and device_map) or device_map == "auto":
-            self.device_map = device_map
-        elif isinstance(device_map, str) and "," in device_map:
-            device_map = device_map.replace(" ", "")  # Remove any spaces
-            self.device_list = [int(dev) for dev in device_map.split(",") if dev.isdigit()]
-            self.device_map = "auto"
-        else:
-            self.device_map = None
-        self._set_device_map_in_blocks(self.device_map)
 
         # Model related
         self.quantized = False
         if isinstance(model, str):
             model, tokenizer, low_cpu_mem_usage = llm_load_model(
                 model,
-                device="cpu",
-                low_cpu_mem_mode=low_cpu_mem_usage,  # always load cpu first
+                device="cpu", # always load cpu first
+                low_cpu_mem_mode=low_cpu_mem_usage,
             )
         elif tokenizer is None and iters > 0:
             raise ValueError("A tokenizer must be set for non-str model input")
@@ -289,17 +277,23 @@ def __init__(
         self.tokenizer = tokenizer
         self.shared_cache_keys = get_shared_keys(self.model)
 
-        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
-        if len(not_quantize_layer_names) > 0:
-            logger.info(f"{not_quantize_layer_names} will not be quantized.")
-        if layer_config is None:
-            layer_config = {}
-        for name in not_quantize_layer_names:
-            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
-        self._parse_layer_config(layer_config)  # must place after model init
+        self._parse_layer_config(layer_config, fp_layers)  # must place after model init
 
         self.to_quant_block_names = to_quant_block_names
 
+        # Set device, must place after model loading
+        self._set_device(device_map)
+
+        if (isinstance(device_map, dict) and device_map) or device_map == "auto":
+            self.device_map = device_map
+        elif isinstance(device_map, str) and "," in device_map:
+            device_map = device_map.replace(" ", "")  # Remove any spaces
+            self.device_list = [int(dev) for dev in device_map.split(",") if dev.isdigit()]
+            self.device_map = "auto"
+        else:
+            self.device_map = None
+        self._set_device_map_in_blocks(self.device_map)
+
         # Tuning hyperparameters
         self.seed = seed
         set_seed(self.seed)
@@ -385,7 +379,7 @@ def __init__(
             import habana_frameworks.torch.core as htcore  # pylint: disable=E0401
             import habana_frameworks.torch.hpu as hthpu  # pylint: disable=E0401]
 
-    def _set_device(self, device_map):
+    def _set_device(self, device_map:Union[str, torch.device, int,dict])->None:
         if hasattr(self, "device") and self.device is not None:
             return
         if isinstance(device_map, (str, torch.device, int)):
@@ -409,8 +403,16 @@ def _set_device(self, device_map):
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-    def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]]) -> None:
+    def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers) -> None:
         """Parse and set the layer-wise quantization configuration."""
+        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
+        if len(not_quantize_layer_names) > 0:
+            logger.info(f"{not_quantize_layer_names} will not be quantized.")
+        if layer_config is None:
+            layer_config = {}
+        for name in not_quantize_layer_names:
+            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
+
         # Some other quantization configs
         self.layer_config = {} if layer_config is None else layer_config
         scheme_keys = [f.name for f in fields(QuantizationScheme)]
@@ -1709,7 +1711,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         # It is best to modify the model structure in the quantize function and check the format,
         # because it may cause the gguf format to not be exported normally.
         self.model = _handle_moe_model(self.model, formats=formats)
-        self.has_qlayer_outside_block = self._set_layerwise_config(self.layer_config)
+        self.has_qlayer_outside_block = self._set_layerwise_config(model, self.layer_config)
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
         else:
@@ -1935,7 +1937,7 @@ def _quantize_layers(self, layer_names: list, layer_inputs: dict) -> None:
             del layer_input
             clear_memory(q_layer_input)
 
-    def _set_layerwise_config(self, layer_config: dict) -> bool:
+    def _set_layerwise_config(self, model:torch.nn.Module, layer_config: dict) -> bool:
         """
         Sets the layer-wise configuration based on the provided `layer_config`.
         By default, only quantize layers in blocks.
@@ -1950,14 +1952,14 @@ def _set_layerwise_config(self, layer_config: dict) -> bool:
         # Get the names of layers in quantization blocks
         supported_types = self.supported_types
         layers_in_blocks = get_layer_names_in_block(
-            self.model, supported_types, self.quant_block_list, self.inner_supported_types
+            model, supported_types, self.quant_block_list, self.inner_supported_types
         )
-        ##process regex in layer_config
+        # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
         keys = get_quant_keys()
 
-        for n, m in self.model.named_modules():
+        for n, m in model.named_modules():
             # Delete previous configuration to avoid conflicts with prior tuning
             for key in keys:
                 if hasattr(m, key):
@@ -1981,7 +1983,7 @@ def _set_layerwise_config(self, layer_config: dict) -> bool:
                 for match_name in matched_names:
                     layer_config[match_name] = val
             else:
-                tmp_m = get_module(self.model, name)
+                tmp_m = get_module(model, name)
                 if not isinstance(tmp_m, torch.nn.Embedding):  # TODO not good code style
                     raise ValueError(f"key {name} in layer_config is invalid, please have a double check")
 
@@ -1989,17 +1991,17 @@ def _set_layerwise_config(self, layer_config: dict) -> bool:
 
         # Iterate through all modules in the model
         is_gguf = hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)
-        for n, m in self.model.named_modules():
+        for n, m in model.named_modules():
             # Skip unsupported types
             if not isinstance(m, supported_types) and m.__class__.__name__ not in self.inner_supported_types:
-                if n in self.layer_config:
+                if n in layer_config:
                     if not isinstance(m, torch.nn.Embedding):
                         logger.warning(f"{n} is not supported, layer_config {n}: {layer_config[n]} will be ignored.")
-                        self.layer_config.pop(n)
+                        layer_config.pop(n)
                         continue
                     if not is_gguf:
                         if not check_to_quantized(layer_config[n]):
-                            self.layer_config.pop(n)
+                            layer_config.pop(n)
                             continue
                 else:
                     continue
diff --git a/auto_round/data_type/register.py b/auto_round/data_type/register.py
index 12c4406a4..fca259ed6 100644
--- a/auto_round/data_type/register.py
+++ b/auto_round/data_type/register.py
@@ -22,8 +22,7 @@ def register_dtype(names):
     Decorator function used before a Pattern subclass.
 
     Args:
-        cls (class): The subclass of register.
-        name: A string. Define the export type.
+        names: A string. Define the export type.
 
     Returns:
         cls: The class of register.
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index a5c5975c9..7b6cf2f4d 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -14,9 +14,9 @@
 import copy
 from copy import deepcopy
 from dataclasses import dataclass, fields
-from typing import Generator, List, Optional
+from typing import Optional, Iterable
 
-__all__ = ["QuantizationScheme", "preset_name_to_scheme"]
+__all__ = ["QuantizationScheme", "preset_name_to_scheme", "AutoScheme"]
 
 
 @dataclass
@@ -38,7 +38,7 @@ def from_dict(cls, config: dict):
         return cls(**config)
 
     @classmethod
-    def get_attributes(cls: "QuantizationScheme") -> List[str]:
+    def get_attributes(cls: "QuantizationScheme") -> list[str]:
         return [field.name for field in fields(cls)]
 
     def __getitem__(self, key: str):
@@ -180,6 +180,8 @@ def is_preset_scheme(name: str) -> bool:
     }
 )
 
+
+
 # FP8 = asdict(QuantArgs.from_dict({
 #     "bits": 8,
 #     "group_size": 128,
@@ -201,6 +203,18 @@ def is_preset_scheme(name: str) -> bool:
     }
 )
 
+# For AutoScheme 16 bits options
+BF16 = QuantizationScheme.from_dict(
+    {
+        "bits": 16,
+        "group_size": 0,
+        "data_type": "fp",
+        "act_bits": 16,
+        "act_data_type": "fp",
+    }
+)
+
+
 PRESET_SCHEMES = {
     "W4A16": W4A16,
     "W2A16": W2A16,
@@ -211,6 +225,7 @@ def is_preset_scheme(name: str) -> bool:
     "NVFP4": NVFP4,
     "FPW8A16": FPW8A16,
     "FP8_STATIC": FP8_STATIC,
+    "BF16": BF16,
 }
 from auto_round.export.export_to_gguf.config import GGUF_CONFIG
 
@@ -220,3 +235,11 @@ def is_preset_scheme(name: str) -> bool:
     value.pop("embedding", None)
     value.pop("lm_head", None)
     PRESET_SCHEMES[key.upper()] = QuantizationScheme.from_dict(value)
+
+
+@dataclass
+class AutoScheme:
+    options:Optional[Iterable[QuantizationScheme]]
+    target_bits:float
+    shared_layers:Optional[Iterable[Iterable[str]]]=None
+    method:str="naive_pre"
\ No newline at end of file

From 5d80825baa9643790b1ada4061d32818ec82bb04 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 25 Sep 2025 06:15:51 +0000
Subject: [PATCH 02/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__init__.py              |  1 +
 auto_round/__main__.py              |  6 +++---
 auto_round/auto_schemes/__init__.py | 15 +++++++++++++++
 auto_round/autoround.py             |  2 +-
 auto_round/compressors/base.py      |  9 ++++-----
 auto_round/schemes.py               | 11 +++++------
 6 files changed, 29 insertions(+), 15 deletions(-)

diff --git a/auto_round/__init__.py b/auto_round/__init__.py
index 1ce7d5e1e..d7be4984c 100644
--- a/auto_round/__init__.py
+++ b/auto_round/__init__.py
@@ -17,6 +17,7 @@
 from auto_round.schemes import QuantizationScheme, AutoScheme
 from auto_round.utils import LazyImport
 
+
 def __getattr__(name):
     if name == "AutoHfQuantizer":
         from auto_round.inference.auto_quantizer import AutoHfQuantizer
diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 5c77c2f10..a69359db8 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -468,7 +468,8 @@ def tune(args):
     extra_config.mllm_config = mllm_config
     layer_config = {}
     from auto_round.auto_schemes.delta_loss import get_mixed_config_layer_config
-    best_path = get_mixed_config_layer_config(model_name,target_bits=6)
+
+    best_path = get_mixed_config_layer_config(model_name, target_bits=6)
     for item in best_path:
         layer_config[item[0]] = {}
         layer_config[item[0]]["bits"] = item[1]
@@ -491,8 +492,7 @@ def tune(args):
         not_use_best_mse=args.not_use_best_mse,
         enable_adam=args.adam,
         extra_config=extra_config,
-        layer_config=layer_config
-
+        layer_config=layer_config,
     )
 
     model_name = args.model.rstrip("/")
diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index 38d40e023..d3b055be2 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -1,5 +1,20 @@
+# 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.
+
 AUTO_SCHEMES_ALGS = {}
 
+
 def register_dtype(names):
     """Class decorator to register a mixed precision algorithm to the registry.
 
diff --git a/auto_round/autoround.py b/auto_round/autoround.py
index 22d3dc29b..ae1a37677 100644
--- a/auto_round/autoround.py
+++ b/auto_round/autoround.py
@@ -25,7 +25,7 @@
     MLLMCompressor,
 )
 from auto_round.logger import deprecated, logger
-from auto_round.schemes import QuantizationScheme, AutoScheme
+from auto_round.schemes import AutoScheme, QuantizationScheme
 from auto_round.utils import is_mllm_model
 
 
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index fa7ee0bf8..72ca17ddc 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -35,7 +35,7 @@
 from auto_round.export.export_to_gguf.config import GGUF_CONFIG, GGUF_INNER_CONFIG, ModelType
 from auto_round.logger import logger
 from auto_round.low_cpu_mem.utils import get_layers_before_block
-from auto_round.schemes import QuantizationScheme, preset_name_to_scheme, AutoScheme
+from auto_round.schemes import AutoScheme, QuantizationScheme, preset_name_to_scheme
 from auto_round.sign_sgd import SignSGD
 from auto_round.special_model_handler import _handle_moe_model
 from auto_round.utils import (
@@ -255,13 +255,12 @@ def __init__(
         if device_map is None:
             device_map = 0
 
-
         # Model related
         self.quantized = False
         if isinstance(model, str):
             model, tokenizer, low_cpu_mem_usage = llm_load_model(
                 model,
-                device="cpu", # always load cpu first
+                device="cpu",  # always load cpu first
                 low_cpu_mem_mode=low_cpu_mem_usage,
             )
         elif tokenizer is None and iters > 0:
@@ -379,7 +378,7 @@ def __init__(
             import habana_frameworks.torch.core as htcore  # pylint: disable=E0401
             import habana_frameworks.torch.hpu as hthpu  # pylint: disable=E0401]
 
-    def _set_device(self, device_map:Union[str, torch.device, int,dict])->None:
+    def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         if hasattr(self, "device") and self.device is not None:
             return
         if isinstance(device_map, (str, torch.device, int)):
@@ -1937,7 +1936,7 @@ def _quantize_layers(self, layer_names: list, layer_inputs: dict) -> None:
             del layer_input
             clear_memory(q_layer_input)
 
-    def _set_layerwise_config(self, model:torch.nn.Module, layer_config: dict) -> bool:
+    def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> bool:
         """
         Sets the layer-wise configuration based on the provided `layer_config`.
         By default, only quantize layers in blocks.
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 7b6cf2f4d..af51a881e 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -14,7 +14,7 @@
 import copy
 from copy import deepcopy
 from dataclasses import dataclass, fields
-from typing import Optional, Iterable
+from typing import Iterable, Optional
 
 __all__ = ["QuantizationScheme", "preset_name_to_scheme", "AutoScheme"]
 
@@ -181,7 +181,6 @@ def is_preset_scheme(name: str) -> bool:
 )
 
 
-
 # FP8 = asdict(QuantArgs.from_dict({
 #     "bits": 8,
 #     "group_size": 128,
@@ -239,7 +238,7 @@ def is_preset_scheme(name: str) -> bool:
 
 @dataclass
 class AutoScheme:
-    options:Optional[Iterable[QuantizationScheme]]
-    target_bits:float
-    shared_layers:Optional[Iterable[Iterable[str]]]=None
-    method:str="naive_pre"
\ No newline at end of file
+    options: Optional[Iterable[QuantizationScheme]]
+    target_bits: float
+    shared_layers: Optional[Iterable[Iterable[str]]] = None
+    method: str = "naive_pre"

From a4ef4950ad11a523e6c2679384c00b5b4ceadaf6 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 25 Sep 2025 14:19:25 +0800
Subject: [PATCH 03/88] update a little

---
 auto_round/__main__.py | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index a69359db8..adafd095e 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -466,14 +466,6 @@ def tune(args):
     extra_config.tuning_config = tuning_config
     extra_config.scheme_config = scheme_config
     extra_config.mllm_config = mllm_config
-    layer_config = {}
-    from auto_round.auto_schemes.delta_loss import get_mixed_config_layer_config
-
-    best_path = get_mixed_config_layer_config(model_name, target_bits=6)
-    for item in best_path:
-        layer_config[item[0]] = {}
-        layer_config[item[0]]["bits"] = item[1]
-        layer_config[item[0]]["act_bits"] = item[1]
 
     autoround: BaseCompressor = AutoRound(
         model=model_name,
@@ -491,8 +483,7 @@ def tune(args):
         fp_layers=args.fp_layers,
         not_use_best_mse=args.not_use_best_mse,
         enable_adam=args.adam,
-        extra_config=extra_config,
-        layer_config=layer_config,
+        extra_config=extra_config
     )
 
     model_name = args.model.rstrip("/")

From 4173c3eb7626b8509896d49c30958029ced1864e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 25 Sep 2025 06:20:01 +0000
Subject: [PATCH 04/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__main__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index adafd095e..78a8fc9d6 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -483,7 +483,7 @@ def tune(args):
         fp_layers=args.fp_layers,
         not_use_best_mse=args.not_use_best_mse,
         enable_adam=args.adam,
-        extra_config=extra_config
+        extra_config=extra_config,
     )
 
     model_name = args.model.rstrip("/")

From 87e945407d7a09cb083a387be574681eee3a1ce0 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 25 Sep 2025 17:04:32 +0800
Subject: [PATCH 05/88] update a little

---
 auto_round/compressors/base.py |  5 ++---
 auto_round/utils.py            | 18 ------------------
 2 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 72ca17ddc..f08540207 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -75,7 +75,6 @@
     get_lm_head_name,
     get_max_vram,
     get_module,
-    get_quant_keys,
     get_shared_keys,
     htcore,
     infer_bits_by_data_type,
@@ -1710,7 +1709,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         # It is best to modify the model structure in the quantize function and check the format,
         # because it may cause the gguf format to not be exported normally.
         self.model = _handle_moe_model(self.model, formats=formats)
-        self.has_qlayer_outside_block = self._set_layerwise_config(model, self.layer_config)
+        self.has_qlayer_outside_block = self._set_layerwise_config(self.model, self.layer_config)
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
         else:
@@ -1956,7 +1955,7 @@ def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> b
         # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
-        keys = get_quant_keys()
+        keys = [f.name for f in fields(QuantizationScheme)]
 
         for n, m in model.named_modules():
             # Delete previous configuration to avoid conflicts with prior tuning
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 9af09758e..131a91db3 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2308,24 +2308,6 @@ def convert_fp8_model_to_16b_model(model, dtype=torch.bfloat16):
     return model
 
 
-def get_quant_keys():
-    keys = [
-        "bits",
-        "group_size",
-        "sym",
-        "data_type",
-        "scale_dtype",
-        "act_bits",
-        "act_group_size",
-        "act_sym",
-        "act_dynamic",
-        "act_data_type",
-        "super_bits",
-        "super_group_size",
-    ]
-    return keys
-
-
 def out_of_vram(error_msg):
     error_msg = str(error_msg)
     # CUDA

From 242d1ee29eb4833f0f2aba2d322e0380f8712ea5 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 25 Sep 2025 17:28:48 +0800
Subject: [PATCH 06/88] try to refine parse layer config code

---
 auto_round/compressors/base.py | 179 +++++++++++++++++++++++++++++++++
 auto_round/utils.py            |   5 +-
 2 files changed, 182 insertions(+), 2 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index f08540207..cbe95703b 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -401,6 +401,185 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
+
+
+    # TODO gguf apply mixd bits, so the gguf scheme meanings in scheme and autoscheme are different
+    def _convert_value_layer_config_to_dict(self,
+                                            layer_config: dict[str, Union[str, dict, QuantizationScheme]]) -> dict:
+
+        new_layer_config = {} if layer_config is None else layer_config
+        scheme_keys = [f.name for f in fields(QuantizationScheme)]
+        for key, item in new_layer_config.items():
+            if isinstance(item, str):
+                item = asdict(preset_name_to_scheme(item.upper()))
+                new_layer_config[key] = item
+            elif isinstance(item, QuantizationScheme):
+                config = asdict(item)
+                tmp_keys = copy.deepcopy(list(config.keys()))
+                for tmp_key in tmp_keys:  # Pop None value to be overridden
+                    if config[tmp_key] is None:
+                        config.pop(tmp_key)
+            elif isinstance(item, dict):
+                item_keys = item.keys()
+                if item_keys not in scheme_keys:
+                    for item_key in item_keys:
+                        if item_key not in scheme_keys:
+                            raise ValueError(
+                                f"the key {item_key} in layer_config for layer {key} is invalid,"
+                                f" only {scheme_keys} are supported"
+                            )
+            new_layer_config[key]["fixed_by_user"] = True
+        return new_layer_config
+
+    def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, dict], fp_layers, quant_lm_head,
+                             scheme, quant_block_list, supported_types, inner_supported_types):
+        """
+       Sets the layer-wise configuration based on the provided `layer_config`.
+       By default, only quantize layers in blocks.
+
+       Args:
+           layer_config (dict): The configuration dictionary for each layer containing various configuration options.
+
+       Returns:
+           bool: Returns True if there are quantized layers outside the blocks (e.g., lm-head),
+                 otherwise returns False.
+       """
+
+        # set fp layers
+        not_quantize_layer_names = get_fp_layer_names(model, fp_layers)
+        # if len(not_quantize_layer_names) > 0:
+        #     logger.info(f"{not_quantize_layer_names} will not be quantized.")
+        if layer_config is None:
+            layer_config = {}
+        for name in not_quantize_layer_names:
+            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float",
+                                  "act_data_type": "float", "fixed_by_user": True}
+
+        # Get the names of layers in quantization blocks
+        layers_in_blocks = get_layer_names_in_block(
+            model, supported_types, quant_block_list, inner_supported_types
+        )
+        # Process regex in layer_config
+        all_supported_layer_names = []
+        # List of configuration keys
+        scheme_keys = (f.name for f in fields(QuantizationScheme))
+
+        for n, m in model.named_modules():
+            # Delete previous configuration to avoid conflicts with prior tuning
+            for key in scheme_keys:
+                if hasattr(m, key):
+                    delattr(m, key)
+            if type(m) not in supported_types and m.__class__.__name__ not in self.inner_supported_types:
+                continue
+            all_supported_layer_names.append(n)
+
+        names_in_layer_config = list(layer_config.keys())
+        for name in names_in_layer_config:
+            if name in all_supported_layer_names:
+                continue
+            matched_names = []
+            for layer_name in all_supported_layer_names:
+                if re.search(re.compile(name), layer_name) is not None:
+                    matched_names.append(layer_name)
+            if len(matched_names) > 0:
+                val = layer_config[name]
+                layer_config.pop(name)
+                for match_name in matched_names:
+                    layer_config[match_name] = val
+            else:
+                tmp_m = get_module(model, name)
+                if type(tmp_m) != torch.nn.Embedding:  # GGUF needs to quantize embedding layer
+                    raise ValueError(f"key {name} in layer_config is invalid, please have a double check")
+
+        has_qlayer_outside_block = False  # Flag to track if there are quantized layers outside blocks (e.g., lm-head)
+
+        # Iterate through all modules in the model
+        is_gguf = ("gguf" in scheme.lower() or
+                   (hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)))
+        for n, m in model.named_modules():
+            # Skip unsupported types
+            if not isinstance(m, supported_types) and m.__class__.__name__ not in self.inner_supported_types:
+                if n in layer_config:
+                    if not isinstance(m, torch.nn.Embedding):
+                        logger.warning(f"{n} is not supported, layer_config {n}: {layer_config[n]} will be ignored.")
+                        layer_config.pop(n)
+
+                    if not is_gguf:  # TODO the code here seems to could be deleted
+                        if not check_to_quantized(layer_config[n]):
+                            layer_config.pop(n)
+
+                continue
+
+            # If the layer is not in the config and is part of a quantization block, use default configuration
+            if n not in layer_config.keys() and n in layers_in_blocks:
+                layer_config[n] = {}
+                for key in scheme_keys:
+                    layer_config[n][key] = getattr(self, key)
+
+            # If the layer is partially configured, fill in missing values
+            elif n in layer_config.keys():
+                if "data_type" in layer_config[n] and "bits" not in layer_config[n]:
+                    tmp_bits = infer_bits_by_data_type(layer_config[n]["data_type"])
+                    if tmp_bits is not None and tmp_bits != self.bits:
+                        logger.warning(
+                            f"'data_type' do not match the specified 'bits' setting for {n}."
+                            f" Resetting 'bits' to {tmp_bits}."
+                        )
+                        layer_config[n]["bits"] = tmp_bits
+                if "act_data_type" in layer_config[n] and "act_bits" not in layer_config[n]:
+                    tmp_bits = infer_bits_by_data_type(layer_config[n]["act_data_type"])
+                    if tmp_bits is not None and tmp_bits != self.act_bits:
+                        logger.warning(
+                            f"'act_data_type' do not match the specified 'act_bits' setting for {n}."
+                            f" Resetting 'act_bits' to {tmp_bits}."
+                        )
+                        layer_config[n]["act_bits"] = tmp_bits
+
+                for key in scheme_keys:
+                    if key not in layer_config[n].keys():
+                        layer_config[n][key] = getattr(self, key)
+                layer_config[n]["fixed_by_user"] = True
+
+            # If the layer is not in the config and not part of a quantization block,
+            # use default configuration and set specific values
+            else:
+                layer_config[n] = {}
+                for key in scheme_keys:
+                    layer_config[n][key] = getattr(self, key)
+                layer_config[n]["bits"] = 16
+                layer_config[n]["act_bits"] = 16
+
+            if n in layers_in_blocks:
+                layer_config[n]["in_blocks"] = True
+            else:
+                layer_config[n]["in_blocks"] = False
+
+            # If the layer is outside a block and requires quantization, mark it as a quantized layer outside the block
+            if (
+                    n not in layers_in_blocks
+                    and check_to_quantized(layer_config[n])
+                    and not isinstance(m, torch.nn.Embedding)
+            ):
+                has_qlayer_outside_block = True
+
+            in_features, out_features = get_layer_features(m)
+            if in_features <= layer_config[n]["group_size"]:
+                layer_config[n]["group_size"] = -1
+
+            # Apply the configuration to the corresponding layer in the model
+            for key in scheme_keys:
+                setattr(m, key, layer_config[n][key])
+
+
+        # TODO self.quant_lm_head has not handleed yet
+
+        need_to_quantize_lm_head = self._check_need_to_quantize_lm_head_embedding()
+        if need_to_quantize_lm_head:
+            has_qlayer_outside_block = True
+
+        # Return whether there are quantized layers outside the blocks
+        return has_qlayer_outside_block
+
     def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers) -> None:
         """Parse and set the layer-wise quantization configuration."""
         not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 131a91db3..bd3d1d2b5 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -21,6 +21,7 @@
 import re
 import sys
 from collections import UserDict
+from dataclasses import fields
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -2278,8 +2279,8 @@ def convert_fp8_layer_to_linear(layer, dtype=torch.bfloat16):
     new_layer = torch.nn.Linear(layer.in_features, layer.out_features, bias=layer.bias is not None, dtype=dtype)
     if layer.bias is not None:
         new_layer.bias.data.copy_(layer.bias.data.to(dtype=dtype))
-
-    keys = get_quant_keys() + ["tmp_name"]
+    scheme_keys = [f.name for f in fields(QuantizationScheme)]
+    keys = scheme_keys + ["tmp_name"]
     for key in keys:
         setattr(new_layer, key, getattr(layer, key, None))
 

From 4fc6b64a56d0fa811f0f210833f366acebe9c918 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 25 Sep 2025 09:29:46 +0000
Subject: [PATCH 07/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 61 ++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 25 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index cbe95703b..0cb65f332 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -401,11 +401,10 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-
-
     # TODO gguf apply mixd bits, so the gguf scheme meanings in scheme and autoscheme are different
-    def _convert_value_layer_config_to_dict(self,
-                                            layer_config: dict[str, Union[str, dict, QuantizationScheme]]) -> dict:
+    def _convert_value_layer_config_to_dict(
+        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]]
+    ) -> dict:
 
         new_layer_config = {} if layer_config is None else layer_config
         scheme_keys = [f.name for f in fields(QuantizationScheme)]
@@ -431,19 +430,28 @@ def _convert_value_layer_config_to_dict(self,
             new_layer_config[key]["fixed_by_user"] = True
         return new_layer_config
 
-    def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, dict], fp_layers, quant_lm_head,
-                             scheme, quant_block_list, supported_types, inner_supported_types):
+    def _expand_layer_config(
+        self,
+        model: torch.nn.Module,
+        layer_config: dict[str, dict],
+        fp_layers,
+        quant_lm_head,
+        scheme,
+        quant_block_list,
+        supported_types,
+        inner_supported_types,
+    ):
         """
-       Sets the layer-wise configuration based on the provided `layer_config`.
-       By default, only quantize layers in blocks.
+        Sets the layer-wise configuration based on the provided `layer_config`.
+        By default, only quantize layers in blocks.
 
-       Args:
-           layer_config (dict): The configuration dictionary for each layer containing various configuration options.
+        Args:
+            layer_config (dict): The configuration dictionary for each layer containing various configuration options.
 
-       Returns:
-           bool: Returns True if there are quantized layers outside the blocks (e.g., lm-head),
-                 otherwise returns False.
-       """
+        Returns:
+            bool: Returns True if there are quantized layers outside the blocks (e.g., lm-head),
+                  otherwise returns False.
+        """
 
         # set fp layers
         not_quantize_layer_names = get_fp_layer_names(model, fp_layers)
@@ -452,13 +460,16 @@ def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, d
         if layer_config is None:
             layer_config = {}
         for name in not_quantize_layer_names:
-            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float",
-                                  "act_data_type": "float", "fixed_by_user": True}
+            layer_config[name] = {
+                "bits": 16,
+                "act_bits": 16,
+                "data_type": "float",
+                "act_data_type": "float",
+                "fixed_by_user": True,
+            }
 
         # Get the names of layers in quantization blocks
-        layers_in_blocks = get_layer_names_in_block(
-            model, supported_types, quant_block_list, inner_supported_types
-        )
+        layers_in_blocks = get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types)
         # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
@@ -494,8 +505,9 @@ def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, d
         has_qlayer_outside_block = False  # Flag to track if there are quantized layers outside blocks (e.g., lm-head)
 
         # Iterate through all modules in the model
-        is_gguf = ("gguf" in scheme.lower() or
-                   (hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)))
+        is_gguf = "gguf" in scheme.lower() or (
+            hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)
+        )
         for n, m in model.named_modules():
             # Skip unsupported types
             if not isinstance(m, supported_types) and m.__class__.__name__ not in self.inner_supported_types:
@@ -556,9 +568,9 @@ def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, d
 
             # If the layer is outside a block and requires quantization, mark it as a quantized layer outside the block
             if (
-                    n not in layers_in_blocks
-                    and check_to_quantized(layer_config[n])
-                    and not isinstance(m, torch.nn.Embedding)
+                n not in layers_in_blocks
+                and check_to_quantized(layer_config[n])
+                and not isinstance(m, torch.nn.Embedding)
             ):
                 has_qlayer_outside_block = True
 
@@ -570,7 +582,6 @@ def _expand_layer_config(self, model: torch.nn.Module, layer_config: dict[str, d
             for key in scheme_keys:
                 setattr(m, key, layer_config[n][key])
 
-
         # TODO self.quant_lm_head has not handleed yet
 
         need_to_quantize_lm_head = self._check_need_to_quantize_lm_head_embedding()

From 7f76db26d3f3c8fe51b777928eb6ca078b22c138 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 26 Sep 2025 05:08:34 +0000
Subject: [PATCH 08/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index e67adfc15..ecf87a62d 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -296,7 +296,7 @@ def __init__(
         for name in not_quantize_layer_names:
             layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
         self._parse_layer_config(layer_config)  # must place after model init
-        
+
         self.to_quant_block_names = to_quant_block_names
 
         # Set device, must place after model loading

From ae8837b0b2bb1e8ef8ae03085d4b6b728977e495 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 13:29:59 +0800
Subject: [PATCH 09/88] fix

---
 auto_round/compressors/base.py | 2 +-
 auto_round/utils.py            | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 53667c090..aaac722ba 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -2145,7 +2145,7 @@ def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> b
         # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
-        keys = [f.name for f in fields(QuantizationScheme)]
+        keys = (f.name for f in fields(QuantizationScheme)) + ("scale_dtype")
 
         for n, m in model.named_modules():
             # Delete previous configuration to avoid conflicts with prior tuning
diff --git a/auto_round/utils.py b/auto_round/utils.py
index dedaf5c2c..a48751d3e 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2279,8 +2279,8 @@ def convert_fp8_layer_to_linear(layer, dtype=torch.bfloat16):
     new_layer = torch.nn.Linear(layer.in_features, layer.out_features, bias=layer.bias is not None, dtype=dtype)
     if layer.bias is not None:
         new_layer.bias.data.copy_(layer.bias.data.to(dtype=dtype))
-    scheme_keys = [f.name for f in fields(QuantizationScheme)]
-    keys = scheme_keys + ["tmp_name"]
+    scheme_keys = (f.name for f in fields(QuantizationScheme))
+    keys = scheme_keys + ("tmp_name", "scale_dtype")
     for key in keys:
         setattr(new_layer, key, getattr(layer, key, None))
 

From 531224de42da3f9ed466bc30c15121ec5597e80f Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 13:34:11 +0800
Subject: [PATCH 10/88] fix

---
 auto_round/compressors/base.py | 13 +++----------
 auto_round/utils.py            |  2 +-
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 71df8b89f..8c0b699a2 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -230,7 +230,7 @@ def __init__(
         self.mllm = kwargs.pop("mllm") if "mllm" in kwargs else False
         # Scale factor for RAM usage per parameter.
         self.mem_per_param_scale = kwargs.pop("mem_per_param_scale", None)
-        fp_layers = kwargs.pop("fp_layers", None)
+        fp_layers = kwargs.pop("fp_layers", "")
 
         if kwargs:
             logger.warning(f"unrecognized keys {list(kwargs.keys())} were passed. Please check them.")
@@ -288,14 +288,7 @@ def __init__(
             self.device_map = None
         self._set_device_map_in_blocks(self.device_map)
 
-        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
-        if len(not_quantize_layer_names) > 0:
-            logger.info(f"{not_quantize_layer_names} will not be quantized.")
-        if layer_config is None:
-            layer_config = {}
-        for name in not_quantize_layer_names:
-            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
-        self._parse_layer_config(layer_config)  # must place after model init
+        self._parse_layer_config(layer_config, fp_layers)  # Must place after model init
 
         self.to_quant_block_names = to_quant_block_names
 
@@ -611,7 +604,7 @@ def _expand_layer_config(
         # Return whether there are quantized layers outside the blocks
         return has_qlayer_outside_block
 
-    def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers) -> None:
+    def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers:str) -> None:
         """Parse and set the layer-wise quantization configuration."""
         not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
         if len(not_quantize_layer_names) > 0:
diff --git a/auto_round/utils.py b/auto_round/utils.py
index a48751d3e..1cb36f2fb 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1046,7 +1046,7 @@ def can_pack_with_numba():  # pragma: no cover
     return True
 
 
-def get_fp_layer_names(model, fp_layers):
+def get_fp_layer_names(model:torch.nn.Module, fp_layers:str):
     """Identifies and returns layers in the model to exclude from quantization.
 
     This function processes a comma-separated list of fully precision (FP) layers,

From c9fa4088aee6d24b05993ea2d3766105ab6793db Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 26 Sep 2025 05:34:44 +0000
Subject: [PATCH 11/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 4 +++-
 auto_round/utils.py            | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 8c0b699a2..bc83e041a 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -604,7 +604,9 @@ def _expand_layer_config(
         # Return whether there are quantized layers outside the blocks
         return has_qlayer_outside_block
 
-    def _parse_layer_config(self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers:str) -> None:
+    def _parse_layer_config(
+        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers: str
+    ) -> None:
         """Parse and set the layer-wise quantization configuration."""
         not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
         if len(not_quantize_layer_names) > 0:
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 1cb36f2fb..8525d7a88 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1046,7 +1046,7 @@ def can_pack_with_numba():  # pragma: no cover
     return True
 
 
-def get_fp_layer_names(model:torch.nn.Module, fp_layers:str):
+def get_fp_layer_names(model: torch.nn.Module, fp_layers: str):
     """Identifies and returns layers in the model to exclude from quantization.
 
     This function processes a comma-separated list of fully precision (FP) layers,

From 6453200001920d6c9a0402680aaf4507bc45924a Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 13:41:32 +0800
Subject: [PATCH 12/88] fix

---
 auto_round/compressors/base.py | 2 +-
 auto_round/utils.py            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 8c0b699a2..2512ef5e8 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -2158,7 +2158,7 @@ def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> b
         # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
-        keys = (f.name for f in fields(QuantizationScheme)) + ("scale_dtype")
+        keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype")
 
         for n, m in model.named_modules():
             # Delete previous configuration to avoid conflicts with prior tuning
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 1cb36f2fb..9bbdbc161 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2280,7 +2280,7 @@ def convert_fp8_layer_to_linear(layer, dtype=torch.bfloat16):
     if layer.bias is not None:
         new_layer.bias.data.copy_(layer.bias.data.to(dtype=dtype))
     scheme_keys = (f.name for f in fields(QuantizationScheme))
-    keys = scheme_keys + ("tmp_name", "scale_dtype")
+    keys = tuple(scheme_keys) + ("tmp_name", "scale_dtype")
     for key in keys:
         setattr(new_layer, key, getattr(layer, key, None))
 

From 3811010768472c9da67b13213dc1d571d457a8cd Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 14:07:19 +0800
Subject: [PATCH 13/88] tmp_change

---
 auto_round/compressors/base.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 48814853b..c7c3abe40 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -416,7 +416,7 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
 
     # TODO gguf apply mixd bits, so the gguf scheme meanings in scheme and autoscheme are different
     def _convert_value_layer_config_to_dict(
-        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]]
+        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]],default_scheme:QuantizationScheme,
     ) -> dict:
 
         new_layer_config = {} if layer_config is None else layer_config
@@ -441,6 +441,7 @@ def _convert_value_layer_config_to_dict(
                                 f" only {scheme_keys} are supported"
                             )
             new_layer_config[key]["fixed_by_user"] = True
+
         return new_layer_config
 
     def _expand_layer_config(

From 4de7b0879cba422eac13532ed716df816b06c6ba Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 14:43:26 +0800
Subject: [PATCH 14/88] commit

---
 auto_round/compressors/base.py | 53 ++++++++++++++++++++++------------
 1 file changed, 35 insertions(+), 18 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index c7c3abe40..067cddeda 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -416,31 +416,48 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
 
     # TODO gguf apply mixd bits, so the gguf scheme meanings in scheme and autoscheme are different
     def _convert_value_layer_config_to_dict(
-        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]],default_scheme:QuantizationScheme,
+            self,
+            layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+            default_scheme: "QuantizationScheme",
+            use_auto_mixed_bit_in_gguf: bool = False,
     ) -> dict:
+        """
+        Convert layer_config values (string, dict, QuantizationScheme) into a standardized dict format.
+        Adds 'fixed_by_user': True for each processed layer config.
+        """
+        if layer_config is None:
+            return {}
+
+        scheme_keys = {f.name for f in fields(QuantizationScheme)}
+        new_layer_config = copy.deepcopy(layer_config)
 
-        new_layer_config = {} if layer_config is None else layer_config
-        scheme_keys = [f.name for f in fields(QuantizationScheme)]
         for key, item in new_layer_config.items():
             if isinstance(item, str):
-                item = asdict(preset_name_to_scheme(item.upper()))
-                new_layer_config[key] = item
+                # Convert preset name to scheme dict
+                config = asdict(preset_name_to_scheme(item.upper()))
             elif isinstance(item, QuantizationScheme):
                 config = asdict(item)
-                tmp_keys = copy.deepcopy(list(config.keys()))
-                for tmp_key in tmp_keys:  # Pop None value to be overridden
-                    if config[tmp_key] is None:
-                        config.pop(tmp_key)
             elif isinstance(item, dict):
-                item_keys = item.keys()
-                if item_keys not in scheme_keys:
-                    for item_key in item_keys:
-                        if item_key not in scheme_keys:
-                            raise ValueError(
-                                f"the key {item_key} in layer_config for layer {key} is invalid,"
-                                f" only {scheme_keys} are supported"
-                            )
-            new_layer_config[key]["fixed_by_user"] = True
+                # Validate dict keys
+                invalid_keys = set(item) - scheme_keys
+                if invalid_keys:
+                    raise ValueError(
+                        f"Invalid keys {invalid_keys} in layer_config for layer '{key}', "
+                        f"only {scheme_keys} are supported."
+                    )
+                config = dict(item)
+            else:
+                raise TypeError(
+                    f"Unsupported type for layer_config[{key}]: {type(item)}. "
+                    f"Expected str, dict, or QuantizationScheme."
+                )
+
+            # Drop None values
+            config = {k: v for k, v in config.items() if v is not None}
+
+            # Mark as user-fixed
+            config["fixed_by_user"] = True
+            new_layer_config[key] = config
 
         return new_layer_config
 

From a9f0e444fff29ca12aafd6dd24bc7e8a933534c1 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 14:44:44 +0800
Subject: [PATCH 15/88] commit

---
 auto_round/compressors/base.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 067cddeda..13ef303a0 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -446,11 +446,6 @@ def _convert_value_layer_config_to_dict(
                         f"only {scheme_keys} are supported."
                     )
                 config = dict(item)
-            else:
-                raise TypeError(
-                    f"Unsupported type for layer_config[{key}]: {type(item)}. "
-                    f"Expected str, dict, or QuantizationScheme."
-                )
 
             # Drop None values
             config = {k: v for k, v in config.items() if v is not None}

From 59a9f5df246da7d9676d6315435b6626da07e582 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 16:39:17 +0800
Subject: [PATCH 16/88] update a little

---
 auto_round/compressors/base.py | 116 +++++++++++++++++++++++++++------
 auto_round/schemes.py          |  14 +++-
 2 files changed, 109 insertions(+), 21 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 13ef303a0..c12aea15f 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -414,47 +414,125 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-    # TODO gguf apply mixd bits, so the gguf scheme meanings in scheme and autoscheme are different
-    def _convert_value_layer_config_to_dict(
+    def _prepare_layer_config(
             self,
-            layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+            model: torch.nn.Module,
+            orig_layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
             default_scheme: "QuantizationScheme",
-            use_auto_mixed_bit_in_gguf: bool = False,
+            supported_types,
+            inner_supported_types,
+            fp_layers: str = "",
+            quant_lm_head: bool = False,
     ) -> dict:
         """
-        Convert layer_config values (string, dict, QuantizationScheme) into a standardized dict format.
-        Adds 'fixed_by_user': True for each processed layer config.
+        Normalize and validate layer-specific quantization schemes,
+        expand regex-based configs, and merge with default scheme.
         """
-        if layer_config is None:
-            return {}
+        from auto_round.schemes import is_gguf_scheme
 
         scheme_keys = {f.name for f in fields(QuantizationScheme)}
-        new_layer_config = copy.deepcopy(layer_config)
+        layer_config = copy.deepcopy(orig_layer_config) or {}
+
+        # Mark layers that should stay in FP
+        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
+        for name in not_quantize_layer_names:
+            layer_config[name] = {
+                "bits": 16,
+                "act_bits": 16,
+                "data_type": "float",
+                "act_data_type": "float",
+            }
 
-        for key, item in new_layer_config.items():
+        def normalize_item(item, layer_name: str) -> dict:
+            """Convert a single config entry to dict and validate keys."""
             if isinstance(item, str):
-                # Convert preset name to scheme dict
                 config = asdict(preset_name_to_scheme(item.upper()))
             elif isinstance(item, QuantizationScheme):
                 config = asdict(item)
             elif isinstance(item, dict):
-                # Validate dict keys
                 invalid_keys = set(item) - scheme_keys
                 if invalid_keys:
                     raise ValueError(
-                        f"Invalid keys {invalid_keys} in layer_config for layer '{key}', "
+                        f"Invalid keys {invalid_keys} in layer_config for layer '{layer_name}', "
                         f"only {scheme_keys} are supported."
                     )
                 config = dict(item)
-
-            # Drop None values
+            else:
+                raise TypeError(
+                    f"Unsupported type for layer_config[{layer_name}]: {type(item)}. "
+                    f"Expected str, dict, or QuantizationScheme."
+                )
+            # Drop None values & mark as fixed
             config = {k: v for k, v in config.items() if v is not None}
-
-            # Mark as user-fixed
             config["fixed_by_user"] = True
-            new_layer_config[key] = config
+            return config
+
+        # Normalize configs
+        layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
+
+        # Infer missing bits from data_type / act_data_type
+        for cfg in layer_config.values():
+            if "data_type" in cfg and "bits" not in cfg:
+                if (tmp_bits := infer_bits_by_data_type(cfg["data_type"])) is not None:
+                    cfg["bits"] = tmp_bits
+            if "act_data_type" in cfg and "act_bits" not in cfg:
+                if (tmp_bits := infer_bits_by_data_type(cfg["act_data_type"])) is not None:
+                    cfg["act_bits"] = tmp_bits
+
+        # Fill missing values from default scheme
+        default_dict = asdict(default_scheme)
+        for cfg in layer_config.values():
+            for scheme_key in scheme_keys:
+                cfg.setdefault(scheme_key, default_dict.get(scheme_key))
+
+        # Special case for GGUF
+        is_gguf = is_gguf_scheme(default_scheme)
+        if is_gguf and torch.nn.Embedding not in supported_types:
+            supported_types = tuple(list(supported_types) + [torch.nn.Embedding])
+
+        # Collect all supported layer names
+        all_supported_layer_names = []
+        for n, m in model.named_modules():
+            # Clear old attributes to avoid conflicts
+            for key in scheme_keys:
+                if hasattr(m, key):
+                    delattr(m, key)
+            if type(m) not in supported_types and m.__class__.__name__ not in inner_supported_types:
+                continue
+            all_supported_layer_names.append(n)
+
+        # Expand regex configs (compile once, reuse)
+        for name in list(layer_config.keys()):
+            if name in all_supported_layer_names:
+                continue
+            regex = re.compile(name)
+            matched_names = [ln for ln in all_supported_layer_names if regex.search(ln)]
+            if matched_names:
+                val = layer_config.pop(name)
+                for match_name in matched_names:
+                    layer_config[match_name] = val
+            else:
+                raise ValueError(f"Key '{name}' in layer_config is invalid, please double check.")
+
+        # Enforce group_size = 32 constraint for INT weight-only quantization
+        if default_scheme.data_type == "int" and default_scheme.act_bits >= 16 and not is_gguf:
+            for n, m in model.named_modules():
+                if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
+                    if m.weight.shape[0] % 32 != 0 or m.weight.shape[1] % 32 != 0:
+                        if n in layer_config:
+                            layer_config[n]["bits"] = 16
+                            layer_config[n]["data_type"] = "fp"
+                        logger.warning_once(
+                            f"{n} will not be quantized because its shape is not divisible by 32. "
+                            "It will be exported in FP16 instead."
+                        )
+
+        # Handle lm_head
+        lm_head_name = get_lm_head_name(model)
+        if lm_head_name not in layer_config and (quant_lm_head or is_gguf):
+            layer_config[lm_head_name] = default_dict.copy()
 
-        return new_layer_config
+        return layer_config
 
     def _expand_layer_config(
         self,
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index af51a881e..9c12b61c0 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -14,9 +14,9 @@
 import copy
 from copy import deepcopy
 from dataclasses import dataclass, fields
-from typing import Iterable, Optional
+from typing import Iterable, Optional, Union
 
-__all__ = ["QuantizationScheme", "preset_name_to_scheme", "AutoScheme"]
+__all__ = ["QuantizationScheme", "is_gguf_scheme", "preset_name_to_scheme", "AutoScheme"]
 
 
 @dataclass
@@ -235,6 +235,16 @@ def is_preset_scheme(name: str) -> bool:
     value.pop("lm_head", None)
     PRESET_SCHEMES[key.upper()] = QuantizationScheme.from_dict(value)
 
+def is_gguf_scheme(scheme:Union[str, QuantizationScheme])->bool:
+    if isinstance(scheme,str) and scheme.upper().startswith("GGUF"):
+        return True
+    for key, val in PRESET_SCHEMES.items():
+        if not key.upper().startswith("GGUF"):
+            continue
+        if val==scheme:
+            return True
+    return False
+
 
 @dataclass
 class AutoScheme:

From 1b7e911656995558c6ea900a09f97f705cadd089 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 26 Sep 2025 08:39:58 +0000
Subject: [PATCH 17/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 16 ++++++++--------
 auto_round/schemes.py          |  7 ++++---
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index c12aea15f..e8bb2fad2 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -415,14 +415,14 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
     def _prepare_layer_config(
-            self,
-            model: torch.nn.Module,
-            orig_layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
-            default_scheme: "QuantizationScheme",
-            supported_types,
-            inner_supported_types,
-            fp_layers: str = "",
-            quant_lm_head: bool = False,
+        self,
+        model: torch.nn.Module,
+        orig_layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+        default_scheme: "QuantizationScheme",
+        supported_types,
+        inner_supported_types,
+        fp_layers: str = "",
+        quant_lm_head: bool = False,
     ) -> dict:
         """
         Normalize and validate layer-specific quantization schemes,
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 9c12b61c0..97a3cdf02 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -235,13 +235,14 @@ def is_preset_scheme(name: str) -> bool:
     value.pop("lm_head", None)
     PRESET_SCHEMES[key.upper()] = QuantizationScheme.from_dict(value)
 
-def is_gguf_scheme(scheme:Union[str, QuantizationScheme])->bool:
-    if isinstance(scheme,str) and scheme.upper().startswith("GGUF"):
+
+def is_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> bool:
+    if isinstance(scheme, str) and scheme.upper().startswith("GGUF"):
         return True
     for key, val in PRESET_SCHEMES.items():
         if not key.upper().startswith("GGUF"):
             continue
-        if val==scheme:
+        if val == scheme:
             return True
     return False
 

From e0680493b54b9e64e0eb8d26219435c2c3f58170 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 16:44:08 +0800
Subject: [PATCH 18/88] fix

---
 auto_round/compressors/base.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index c12aea15f..7538fc362 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -519,12 +519,13 @@ def normalize_item(item, layer_name: str) -> dict:
             for n, m in model.named_modules():
                 if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
                     if m.weight.shape[0] % 32 != 0 or m.weight.shape[1] % 32 != 0:
-                        if n in layer_config:
-                            layer_config[n]["bits"] = 16
-                            layer_config[n]["data_type"] = "fp"
+                        if n not in layer_config:
+                            layer_config[n] = default_dict.copy()
+                        layer_config[n]["bits"] = 16
+                        layer_config[n]["data_type"] = "fp"
+                        layer_config[n]["fixed_by_user"] = True
                         logger.warning_once(
                             f"{n} will not be quantized because its shape is not divisible by 32. "
-                            "It will be exported in FP16 instead."
                         )
 
         # Handle lm_head

From 0357c0b94b7070da52c9492212be961fab69994e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 26 Sep 2025 08:45:30 +0000
Subject: [PATCH 19/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index a1558d247..182cc435f 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -524,9 +524,7 @@ def normalize_item(item, layer_name: str) -> dict:
                         layer_config[n]["bits"] = 16
                         layer_config[n]["data_type"] = "fp"
                         layer_config[n]["fixed_by_user"] = True
-                        logger.warning_once(
-                            f"{n} will not be quantized because its shape is not divisible by 32. "
-                        )
+                        logger.warning_once(f"{n} will not be quantized because its shape is not divisible by 32. ")
 
         # Handle lm_head
         lm_head_name = get_lm_head_name(model)

From 602421c6ab2340476ece3a6959409b7d58be8320 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 26 Sep 2025 18:22:47 +0800
Subject: [PATCH 20/88] merge autoscheme to scheme

---
 auto_round/compressors/base.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 8dbb0e3cc..0e21e00d5 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -128,8 +128,7 @@ def __init__(
         self,
         model: Union[torch.nn.Module, str],
         tokenizer=None,
-        scheme: Union[str, dict, QuantizationScheme] = "W4A16",
-        auto_scheme: AutoScheme = None,
+        scheme: Union[str, dict, QuantizationScheme, AutoScheme] = "W4A16",
         layer_config: dict[str, Union[str, dict, QuantizationScheme]] = None,
         dataset: Union[str, list, tuple, torch.utils.data.DataLoader] = "NeelNanda/pile-10k",
         iters: int = 200,
@@ -2247,7 +2246,7 @@ def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> b
         # Process regex in layer_config
         all_supported_layer_names = []
         # List of configuration keys
-        keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype")
+        keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype",)
 
         for n, m in model.named_modules():
             # Delete previous configuration to avoid conflicts with prior tuning

From 091c5ad0e9045dbcc693aa3163ca4ec476ddf44f Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 14:31:43 +0800
Subject: [PATCH 21/88] refine layer_config code

---
 auto_round/__main__.py         |  10 +
 auto_round/autoround.py        |   4 +-
 auto_round/compressors/base.py | 635 +++++++++------------------------
 auto_round/schemes.py          |   8 +-
 auto_round/utils.py            |  18 +-
 5 files changed, 191 insertions(+), 484 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 07bc3f273..43f55a050 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -470,6 +470,15 @@ def tune(args):
     extra_config.scheme_config = scheme_config
     extra_config.mllm_config = mllm_config
 
+    layer_config = {}
+    # from auto_round.auto_schemes.haha import get_mixed_config_layer_config
+    # layer_config = {}
+    # best_path = get_mixed_config_layer_config(model_name, target_bits=3)
+    # for item in best_path:
+    #     layer_config[item[0]] = {}
+    #     layer_config[item[0]]["bits"] = item[1]
+
+
     autoround: BaseCompressor = AutoRound(
         model=model_name,
         scheme=scheme,
@@ -486,6 +495,7 @@ def tune(args):
         not_use_best_mse=args.not_use_best_mse,
         enable_adam=args.adam,
         extra_config=extra_config,
+        layer_config=layer_config,
     )
 
     model_name = args.model.rstrip("/")
diff --git a/auto_round/autoround.py b/auto_round/autoround.py
index ae1a37677..ccdca1f09 100644
--- a/auto_round/autoround.py
+++ b/auto_round/autoround.py
@@ -63,8 +63,7 @@ def __new__(
         cls,
         model: Union[torch.nn.Module, str],
         tokenizer=None,
-        scheme: Union[str, dict, QuantizationScheme] = "W4A16",
-        auto_scheme: AutoScheme = None,
+        scheme: Union[str, dict, QuantizationScheme, AutoScheme] = "W4A16",
         layer_config: dict[str, Union[str, dict, QuantizationScheme]] = None,
         dataset: Union[str, list, tuple, torch.utils.data.DataLoader] = "NeelNanda/pile-10k",
         iters: int = 200,
@@ -159,7 +158,6 @@ def __new__(
             model=model,
             tokenizer=tokenizer,
             scheme=scheme,
-            auto_scheme=auto_scheme,
             layer_config=layer_config,
             dataset=dataset,
             iters=iters,
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 0e21e00d5..590c480e8 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -35,7 +35,7 @@
 from auto_round.export.export_to_gguf.config import GGUF_CONFIG, GGUF_INNER_CONFIG, ModelType
 from auto_round.logger import logger
 from auto_round.low_cpu_mem.utils import get_layers_before_block
-from auto_round.schemes import AutoScheme, QuantizationScheme, preset_name_to_scheme
+from auto_round.schemes import AutoScheme, QuantizationScheme, preset_name_to_scheme, get_gguf_scheme
 from auto_round.sign_sgd import SignSGD
 from auto_round.special_model_handler import _handle_moe_model
 from auto_round.utils import (
@@ -201,8 +201,7 @@ def __init__(
             ...     # ...
             ... }
         """
-        self.scheme = None
-        self._parse_and_set_scheme(scheme, kwargs)
+        self.scheme = self._parse_and_set_scheme(scheme, kwargs)
         # Extra/legacy kwargs for backward compatibility
         # Major version releases may pack them with extra configuration options
         amp = kwargs.pop("amp", True)
@@ -229,7 +228,8 @@ def __init__(
         self.mllm = kwargs.pop("mllm") if "mllm" in kwargs else False
         # Scale factor for RAM usage per parameter.
         self.mem_per_param_scale = kwargs.pop("mem_per_param_scale", None)
-        fp_layers = kwargs.pop("fp_layers", "")
+        self.fp_layers = kwargs.pop("fp_layers", "")
+        self.layer_config = layer_config
 
         if kwargs:
             logger.warning(f"unrecognized keys {list(kwargs.keys())} were passed. Please check them.")
@@ -287,7 +287,7 @@ def __init__(
             self.device_map = None
         self._set_device_map_in_blocks(self.device_map)
 
-        self._parse_layer_config(layer_config, fp_layers)  # Must place after model init
+        # self._parse_layer_config(layer_config, fp_layers)  # Must place after model init
 
         self.to_quant_block_names = to_quant_block_names
 
@@ -414,46 +414,46 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
     def _prepare_layer_config(
-        self,
-        model: torch.nn.Module,
-        orig_layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
-        default_scheme: "QuantizationScheme",
-        supported_types,
-        inner_supported_types,
-        fp_layers: str = "",
-        quant_lm_head: bool = False,
-    ) -> dict:
+            self,
+            model: torch.nn.Module,
+            layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+            default_scheme: "QuantizationScheme",
+            default_scale_dtype: torch.dtype | str,
+            supported_types: tuple,
+            inner_supported_types: tuple,
+            quant_block_list=None,
+            fp_layers: str = "",
+            quant_lm_head: bool = False,
+            enable_gguf_official_mixed: bool = True,
+            is_mllm: bool = False,
+    ) -> tuple[dict, bool]:
         """
-        Normalize and validate layer-specific quantization schemes,
-        expand regex-based configs, and merge with default scheme.
+        Normalize, validate, and expand layer-specific quantization configs.
+        Returns (final_layer_config, has_quant_layer_outside_block)
         """
-        from auto_round.schemes import is_gguf_scheme
 
-        scheme_keys = {f.name for f in fields(QuantizationScheme)}
-        layer_config = copy.deepcopy(orig_layer_config) or {}
+        from auto_round.schemes import get_gguf_scheme
 
-        # Mark layers that should stay in FP
-        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
-        for name in not_quantize_layer_names:
-            layer_config[name] = {
-                "bits": 16,
-                "act_bits": 16,
-                "data_type": "float",
-                "act_data_type": "float",
-            }
+        # ---- helpers -------------------------------------------------
+        def dispatch_layer_config(layer_config: dict[str, dict]) -> None:
+            """Assign scheme values as attributes to matched modules."""
+            for layer_name, scheme in layer_config.items():
+                module = get_module(model, layer_name)
+                for attr, value in scheme.items():
+                    setattr(module, attr, value)
 
-        def normalize_item(item, layer_name: str) -> dict:
-            """Convert a single config entry to dict and validate keys."""
+        def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str) -> dict:
+            """Convert config entry into dict and validate keys."""
             if isinstance(item, str):
                 config = asdict(preset_name_to_scheme(item.upper()))
             elif isinstance(item, QuantizationScheme):
                 config = asdict(item)
             elif isinstance(item, dict):
-                invalid_keys = set(item) - scheme_keys
-                if invalid_keys:
+                invalid = set(item) - set(scheme_keys)
+                if invalid:
                     raise ValueError(
-                        f"Invalid keys {invalid_keys} in layer_config for layer '{layer_name}', "
-                        f"only {scheme_keys} are supported."
+                        f"Invalid keys {invalid} in layer_config for '{layer_name}'. "
+                        f"Allowed keys: {scheme_keys}"
                     )
                 config = dict(item)
             else:
@@ -461,237 +461,135 @@ def normalize_item(item, layer_name: str) -> dict:
                     f"Unsupported type for layer_config[{layer_name}]: {type(item)}. "
                     f"Expected str, dict, or QuantizationScheme."
                 )
-            # Drop None values & mark as fixed
+            # Clean up
             config = {k: v for k, v in config.items() if v is not None}
             config["fixed_by_user"] = True
             return config
 
-        # Normalize configs
+        # ---- main logic ----------------------------------------------
+        scheme_keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype",)
+        layer_config = copy.deepcopy(layer_config) or {}
+
+        # 1. fp_layers -> force 16
+        for name in get_fp_layer_names(self.model, fp_layers):
+            layer_config[name] = {
+                "bits": 16, "act_bits": 16,
+                "data_type": "float", "act_data_type": "float"
+            }
+
+        # 2. normalize
         layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
 
-        # Infer missing bits from data_type / act_data_type
+        # 3. infer missing bits
         for cfg in layer_config.values():
             if "data_type" in cfg and "bits" not in cfg:
-                if (tmp_bits := infer_bits_by_data_type(cfg["data_type"])) is not None:
-                    cfg["bits"] = tmp_bits
+                if (b := infer_bits_by_data_type(cfg["data_type"])) is not None:
+                    cfg["bits"] = b
             if "act_data_type" in cfg and "act_bits" not in cfg:
-                if (tmp_bits := infer_bits_by_data_type(cfg["act_data_type"])) is not None:
-                    cfg["act_bits"] = tmp_bits
+                if (b := infer_bits_by_data_type(cfg["act_data_type"])) is not None:
+                    cfg["act_bits"] = b
 
-        # Fill missing values from default scheme
+        # 4. fill defaults
         default_dict = asdict(default_scheme)
+        default_dict["scale_dtype"] = default_scale_dtype
         for cfg in layer_config.values():
-            for scheme_key in scheme_keys:
-                cfg.setdefault(scheme_key, default_dict.get(scheme_key))
+            for key in scheme_keys:
+                cfg.setdefault(key, default_dict.get(key))
 
-        # Special case for GGUF
-        is_gguf = is_gguf_scheme(default_scheme)
-        if is_gguf and torch.nn.Embedding not in supported_types:
-            supported_types = tuple(list(supported_types) + [torch.nn.Embedding])
+        # 5. collect supported modules
+        gguf_name = get_gguf_scheme(default_scheme)
+        if gguf_name and torch.nn.Embedding not in supported_types:
+            supported_types = (*supported_types, torch.nn.Embedding)
 
-        # Collect all supported layer names
-        all_supported_layer_names = []
+        all_layer_names, embedding_layer_names = [], []
         for n, m in model.named_modules():
-            # Clear old attributes to avoid conflicts
+            # cleanup stale attributes
             for key in scheme_keys:
                 if hasattr(m, key):
                     delattr(m, key)
             if type(m) not in supported_types and m.__class__.__name__ not in inner_supported_types:
                 continue
-            all_supported_layer_names.append(n)
+            all_layer_names.append(n)
+            if isinstance(m, torch.nn.Embedding):
+                embedding_layer_names.append(n)
 
-        # Expand regex configs (compile once, reuse)
+        # 6. expand regex configs
         for name in list(layer_config.keys()):
-            if name in all_supported_layer_names:
+            if name in all_layer_names:
                 continue
             regex = re.compile(name)
-            matched_names = [ln for ln in all_supported_layer_names if regex.search(ln)]
-            if matched_names:
-                val = layer_config.pop(name)
-                for match_name in matched_names:
-                    layer_config[match_name] = val
-            else:
-                raise ValueError(f"Key '{name}' in layer_config is invalid, please double check.")
-
-        # Enforce group_size = 32 constraint for INT weight-only quantization
-        if default_scheme.data_type == "int" and default_scheme.act_bits >= 16 and not is_gguf:
-            for n, m in model.named_modules():
-                if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
-                    if m.weight.shape[0] % 32 != 0 or m.weight.shape[1] % 32 != 0:
-                        if n not in layer_config:
-                            layer_config[n] = default_dict.copy()
-                        layer_config[n]["bits"] = 16
-                        layer_config[n]["data_type"] = "fp"
-                        layer_config[n]["fixed_by_user"] = True
-                        logger.warning_once(f"{n} will not be quantized because its shape is not divisible by 32. ")
-
-        # Handle lm_head
+            matched = [ln for ln in all_layer_names if regex.search(ln)]
+            if not matched:
+                raise ValueError(f"Invalid regex '{name}' in layer_config, no match found.")
+            val = layer_config.pop(name)
+            for match in matched:
+                layer_config[match] = val
+
+        # 7. lm_head
         lm_head_name = get_lm_head_name(model)
-        if lm_head_name not in layer_config and (quant_lm_head or is_gguf):
+        tied_lm_head = False
+        if (
+            hasattr(model, "config")
+            and model.config.tie_word_embeddings
+            and hasattr(model, "_tied_weights_keys")
+        ):
+            tied_keys =model._tied_weights_keys
+            if lm_head_name in tied_keys:
+                tied_lm_head=True
+        if quant_lm_head and tied_lm_head:
+            quant_lm_head=False
+            logger.warning("reset `quant_lm_head` to false as quantizing lm_head with tied weights has not been supported currently")
+
+        if lm_head_name not in layer_config and quant_lm_head:
             layer_config[lm_head_name] = default_dict.copy()
 
-        return layer_config
-
-    def _expand_layer_config(
-        self,
-        model: torch.nn.Module,
-        layer_config: dict[str, dict],
-        fp_layers,
-        quant_lm_head,
-        scheme,
-        quant_block_list,
-        supported_types,
-        inner_supported_types,
-    ):
-        """
-        Sets the layer-wise configuration based on the provided `layer_config`.
-        By default, only quantize layers in blocks.
-
-        Args:
-            layer_config (dict): The configuration dictionary for each layer containing various configuration options.
-
-        Returns:
-            bool: Returns True if there are quantized layers outside the blocks (e.g., lm-head),
-                  otherwise returns False.
-        """
-
-        # set fp layers
-        not_quantize_layer_names = get_fp_layer_names(model, fp_layers)
-        # if len(not_quantize_layer_names) > 0:
-        #     logger.info(f"{not_quantize_layer_names} will not be quantized.")
-        if layer_config is None:
-            layer_config = {}
-        for name in not_quantize_layer_names:
-            layer_config[name] = {
-                "bits": 16,
-                "act_bits": 16,
-                "data_type": "float",
-                "act_data_type": "float",
-                "fixed_by_user": True,
-            }
-
-        # Get the names of layers in quantization blocks
-        layers_in_blocks = get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types)
-        # Process regex in layer_config
-        all_supported_layer_names = []
-        # List of configuration keys
-        scheme_keys = (f.name for f in fields(QuantizationScheme))
-
-        for n, m in model.named_modules():
-            # Delete previous configuration to avoid conflicts with prior tuning
-            for key in scheme_keys:
-                if hasattr(m, key):
-                    delattr(m, key)
-            if type(m) not in supported_types and m.__class__.__name__ not in self.inner_supported_types:
-                continue
-            all_supported_layer_names.append(n)
-
-        names_in_layer_config = list(layer_config.keys())
-        for name in names_in_layer_config:
-            if name in all_supported_layer_names:
-                continue
-            matched_names = []
-            for layer_name in all_supported_layer_names:
-                if re.search(re.compile(name), layer_name) is not None:
-                    matched_names.append(layer_name)
-            if len(matched_names) > 0:
-                val = layer_config[name]
-                layer_config.pop(name)
-                for match_name in matched_names:
-                    layer_config[match_name] = val
-            else:
-                tmp_m = get_module(model, name)
-                if type(tmp_m) != torch.nn.Embedding:  # GGUF needs to quantize embedding layer
-                    raise ValueError(f"key {name} in layer_config is invalid, please have a double check")
-
-        has_qlayer_outside_block = False  # Flag to track if there are quantized layers outside blocks (e.g., lm-head)
-
-        # Iterate through all modules in the model
-        is_gguf = "gguf" in scheme.lower() or (
-            hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)
-        )
-        for n, m in model.named_modules():
-            # Skip unsupported types
-            if not isinstance(m, supported_types) and m.__class__.__name__ not in self.inner_supported_types:
-                if n in layer_config:
-                    if not isinstance(m, torch.nn.Embedding):
-                        logger.warning(f"{n} is not supported, layer_config {n}: {layer_config[n]} will be ignored.")
-                        layer_config.pop(n)
-
-                    if not is_gguf:  # TODO the code here seems to could be deleted
-                        if not check_to_quantized(layer_config[n]):
-                            layer_config.pop(n)
-
-                continue
-
-            # If the layer is not in the config and is part of a quantization block, use default configuration
-            if n not in layer_config.keys() and n in layers_in_blocks:
-                layer_config[n] = {}
-                for key in scheme_keys:
-                    layer_config[n][key] = getattr(self, key)
-
-            # If the layer is partially configured, fill in missing values
-            elif n in layer_config.keys():
-                if "data_type" in layer_config[n] and "bits" not in layer_config[n]:
-                    tmp_bits = infer_bits_by_data_type(layer_config[n]["data_type"])
-                    if tmp_bits is not None and tmp_bits != self.bits:
-                        logger.warning(
-                            f"'data_type' do not match the specified 'bits' setting for {n}."
-                            f" Resetting 'bits' to {tmp_bits}."
-                        )
-                        layer_config[n]["bits"] = tmp_bits
-                if "act_data_type" in layer_config[n] and "act_bits" not in layer_config[n]:
-                    tmp_bits = infer_bits_by_data_type(layer_config[n]["act_data_type"])
-                    if tmp_bits is not None and tmp_bits != self.act_bits:
-                        logger.warning(
-                            f"'act_data_type' do not match the specified 'act_bits' setting for {n}."
-                            f" Resetting 'act_bits' to {tmp_bits}."
-                        )
-                        layer_config[n]["act_bits"] = tmp_bits
-
-                for key in scheme_keys:
-                    if key not in layer_config[n].keys():
-                        layer_config[n][key] = getattr(self, key)
-                layer_config[n]["fixed_by_user"] = True
-
-            # If the layer is not in the config and not part of a quantization block,
-            # use default configuration and set specific values
-            else:
-                layer_config[n] = {}
-                for key in scheme_keys:
-                    layer_config[n][key] = getattr(self, key)
-                layer_config[n]["bits"] = 16
-                layer_config[n]["act_bits"] = 16
-
-            if n in layers_in_blocks:
-                layer_config[n]["in_blocks"] = True
-            else:
-                layer_config[n]["in_blocks"] = False
-
-            # If the layer is outside a block and requires quantization, mark it as a quantized layer outside the block
-            if (
-                n not in layers_in_blocks
-                and check_to_quantized(layer_config[n])
-                and not isinstance(m, torch.nn.Embedding)
-            ):
+        # 8. enforce shape divisibility for int weight-only
+        if default_dict["data_type"] == "int" and default_dict["act_bits"] >= 16 and not gguf_name:
+            for n, m in model.named_modules():
+                if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
+                    if m.weight.shape[0] % 32 or m.weight.shape[1] % 32:
+                        layer_config.setdefault(n, default_dict.copy())
+                        layer_config[n].update({"bits": 16, "data_type": "fp", "fixed_by_user": True})
+                        logger.warning_once(f"{n} skipped quantization (shape not divisible by 32).")
+
+        # 9. block layers: mark as in_blocks=True
+        for name in get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types):
+            cfg = layer_config.setdefault(name, default_dict.copy())
+            cfg["in_blocks"] = True
+
+        # ---- restore: ensure missing in_blocks are set to False and compute flag ----
+        has_qlayer_outside_block = False
+        for cfg in layer_config.values():
+            if "in_blocks" not in cfg:
+                cfg["in_blocks"] = False
+            # 如果 layer 不在 blocks 且需要量化，则标记存在 blocks 外的量化层
+            if not cfg["in_blocks"] and check_to_quantized(cfg):
                 has_qlayer_outside_block = True
 
-            in_features, out_features = get_layer_features(m)
-            if in_features <= layer_config[n]["group_size"]:
-                layer_config[n]["group_size"] = -1
+        # 10. GGUF handling
+        if not gguf_name:
+            dispatch_layer_config(layer_config)
+            return layer_config, has_qlayer_outside_block
 
-            # Apply the configuration to the corresponding layer in the model
-            for key in scheme_keys:
-                setattr(m, key, layer_config[n][key])
+        # embed + lm_head defaults for gguf
+        if lm_head_name not in layer_config and not tied_lm_head:
+            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["lm_head"]]
+            cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
+            layer_config[lm_head_name] = cfg
+            has_qlayer_outside_block = True
+        for emd_name in embedding_layer_names:
+            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
+            cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
+            layer_config[emd_name] = cfg
 
-        # TODO self.quant_lm_head has not handleed yet
+        if enable_gguf_official_mixed:
+            model_type = ModelType.MMPROJ if is_mllm else ModelType.TEXT
+            layer_config, _ = get_layer_config_by_gguf_format(layer_config, gguf_name.lower(), model, model_type)
+
+        dispatch_layer_config(layer_config)
+        return layer_config, has_qlayer_outside_block
 
-        need_to_quantize_lm_head = self._check_need_to_quantize_lm_head_embedding()
-        if need_to_quantize_lm_head:
-            has_qlayer_outside_block = True
 
-        # Return whether there are quantized layers outside the blocks
-        return has_qlayer_outside_block
 
     def _parse_layer_config(
         self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers: str
@@ -753,7 +651,7 @@ def _parse_layer_config(
             if key not in lm_head_layer_config:
                 lm_head_layer_config[key] = getattr(self, key)
 
-    def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> None:
+    def  _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
         if isinstance(scheme, QuantizationScheme):
             scheme = asdict(scheme)
@@ -761,7 +659,6 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
             scheme = scheme
         elif isinstance(scheme, str):
             scheme = scheme.upper()
-            self.scheme = scheme
             scheme = asdict(preset_name_to_scheme(scheme))
         scheme_keys = [f.name for f in fields(QuantizationScheme)]
         for key in scheme_keys:
@@ -807,6 +704,9 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
                     if supported_dtype + str(tmp_act_bits) == self.act_data_type:  # could not replace FP8_e4m3
                         self.act_data_type = supported_dtype
                     break
+        for key in scheme_keys:
+            scheme[key] = getattr(self, key)
+        return QuantizationScheme.from_dict(scheme)
 
     def _adjust_torch_compile(self, enable_torch_compile: bool) -> None:
         """Sets the torch compile configuration for the tuning."""
@@ -1112,19 +1012,29 @@ def remove_duplicates(lst):
         formats = format.replace("q*_", f"q{self.bits}_").replace(" ", "").split(",")
         formats = remove_duplicates(formats)  # need the keep origin order
 
-        if isinstance(self.scheme, str) and self.scheme.lower().startswith("gguf"):
+        gguf_format_name = get_gguf_scheme(self.scheme)
+
+        if gguf_format_name:
             for i in range(len(formats)):
-                if formats[i] != "fake" and formats[i] != self.scheme.lower():
+                if formats[i] != "fake" and formats[i] != gguf_format_name.lower():
                     logger.warning(
-                        f"reset format {formats[i]} to {self.scheme.lower()} "
-                        f"since scheme {self.scheme} can only be exported to format {self.scheme.lower()}"
+                        f"reset format {formats[i]} to {gguf_format_name.lower()} "
+                        f"since scheme {gguf_format_name} can only be exported to format {gguf_format_name.lower()}"
                     )
-                    formats[i] = self.scheme.lower()
+                    formats[i] = gguf_format_name.lower()
+
 
         _gguf_args_check(self, formats, model_type=ModelType.TEXT)
         if self.mllm:
             _gguf_args_check(self, formats, model_type=ModelType.MMPROJ)
 
+        for f in formats:
+            if f.startswith("gguf"):
+                self.scheme = preset_name_to_scheme(f)
+                break
+
+
+
         for format_ in formats:
             if format_ not in SUPPORTED_FORMATS:
                 logger.error(f"Unsupported format {format_}, please choose from {SUPPORTED_FORMATS}")
@@ -1608,91 +1518,6 @@ def get_imatrix_hook(module, input, output):
             for hook in hooks:
                 hook.remove()
 
-    def _check_need_to_quantize_lm_head_embedding(self) -> bool:
-        """Checks if LM head and embedding layers need quantization for GGUF format.
-
-        This function inspects the current model's formats and determines whether
-        it needs to apply quantization settings to the embedding and LM head layers.
-        The function modifies `self.layer_config` in-place and updates the model modules.
-
-        Returns:
-            bool: True if the LM head needs quantization, otherwise False.
-
-        Raises:
-            NotImplementedError: If multiple non-fake GGUF formats are specified.
-        """
-        gguf_scheme = False
-        if isinstance(self.scheme, str) and "gguf" in self.scheme.lower():
-            gguf_scheme = True
-
-        if not hasattr(self, "formats") and not gguf_scheme:
-            return False
-
-        has_gguf: bool = gguf_scheme or any("gguf" in fmt for fmt in self.formats)
-        if not has_gguf:
-            return False
-        if hasattr(self, "formats"):
-            formats: list[str] = [fmt for fmt in self.formats if "fake" not in fmt]
-            if not (len(formats) == 1 and "gguf" in formats[0]):
-                raise NotImplementedError("Only one GGUF format can be set at a time.")
-            target_format: str = formats[0]
-
-        else:
-            target_format = self.scheme.lower()
-
-        tie_word_embeddings: bool = getattr(getattr(self.model, "config", None), "tie_word_embeddings", True)
-        for name, module in self.model.named_modules():
-            if isinstance(module, torch.nn.Embedding):
-                key: str = "lm_head" if tie_word_embeddings else "embedding"
-                config: dict[str, Any] = GGUF_INNER_CONFIG[GGUF_CONFIG[target_format][key]]
-                self._apply_config_to_layer(name, config, True)
-
-        if not tie_word_embeddings:
-            lm_head_name: str = get_lm_head_name(self.model)
-            config: dict[str, Any] = GGUF_CONFIG[GGUF_CONFIG[target_format]["lm_head"]]
-            check_fixed_by_user = (
-                self.layer_config[lm_head_name].get("fixed_by_user", False)
-                if lm_head_name in self.layer_config
-                else None
-            )
-            self._apply_config_to_layer(lm_head_name, config, check_fixed_by_user=check_fixed_by_user)
-            return True
-
-        return False
-
-    def _apply_config_to_layer(
-        self,
-        layer_name: str,
-        config: dict[str, Any],
-        check_fixed_by_user: bool = False,
-    ) -> None:
-        """Applies GGUF quantization configuration to a given layer.
-
-        Args:
-            layer_name (str): Name of the layer to configure.
-            config (dict[str, Any]): GGUF layer configuration.
-            check_fixed_by_user (bool): If True, preserve user-defined settings.
-        """
-        act_bits: int = 16
-        scale_dtype: Any = self.scale_dtype
-        keys: list[str] = ["bits", "group_size", "super_bits", "super_group_size", "data_type", "sym"]
-
-        self.layer_config[layer_name] = self.layer_config.get(layer_name, {})
-
-        for key in keys:
-            if (
-                key in self.layer_config[layer_name]
-                and check_fixed_by_user
-                # and self.layer_config[layer_name].get("fixed_by_user", False)
-            ):
-                continue
-            self.layer_config[layer_name][key] = config.get(key)
-            setattr(get_module(self.model, layer_name), key, config.get(key))
-
-        self.layer_config[layer_name]["act_bits"] = act_bits
-        self.layer_config[layer_name]["scale_dtype"] = scale_dtype
-        setattr(get_module(self.model, layer_name), "act_bits", act_bits)
-        setattr(get_module(self.model, layer_name), "scale_dtype", scale_dtype)
 
     def _quantize_layer_via_rtn(self, name: str) -> None:
         """Quantizes a layer using RTN (Round-To-Nearest) if available.
@@ -1993,14 +1818,21 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         Returns:
         The quantized model and layer configurations.
         """
-        for n, m in self.model.named_modules():
+        for n, m in self.model.named_modules(): # TODO check if could removed
             m.tmp_name = n
         self._check_compatibility()
         formats = self.formats if hasattr(self, "formats") else None
         # It is best to modify the model structure in the quantize function and check the format,
         # because it may cause the gguf format to not be exported normally.
         self.model = _handle_moe_model(self.model, formats=formats)
-        self.has_qlayer_outside_block = self._set_layerwise_config(self.model, self.layer_config)
+        # self.has_qlayer_outside_block = self._set_layerwise_config(self.model, self.layer_config)
+        # TODO check scale_dtype
+        self.layer_config, self.has_qlayer_outside_block = (
+            self._prepare_layer_config(self.model, self.layer_config,self.scheme, self.scale_dtype,
+                                       self.supported_types,self.inner_supported_types,self.quant_block_list,
+                                       self.fp_layers,self.quant_lm_head,
+                                       enable_gguf_official_mixed=True,is_mllm=self.mllm))
+
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
         else:
@@ -2011,14 +1843,14 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
                     break
             if len(self.formats) == 1 and self.formats[0] == "fake":
                 only_gguf = False
-            if only_gguf:
-                self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
-                    self.layer_config, self.formats, self.model, model_type=ModelType.TEXT
-                )
-                if self.mllm:
-                    self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
-                        self.layer_config, self.formats, self.model, model_type=ModelType.MMPROJ
-                    )
+            # if only_gguf:
+            #     self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
+            #         self.layer_config, self.formats, self.model, model_type=ModelType.TEXT
+            #     )
+            #     if self.mllm:
+            #         self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
+            #             self.layer_config, self.formats, self.model, model_type=ModelType.MMPROJ
+            #         )
             # Determine if immediate packing is required
             formats = self.formats
             if (
@@ -2226,141 +2058,6 @@ def _quantize_layers(self, layer_names: list, layer_inputs: dict) -> None:
             del layer_input
             clear_memory(q_layer_input)
 
-    def _set_layerwise_config(self, model: torch.nn.Module, layer_config: dict) -> bool:
-        """
-        Sets the layer-wise configuration based on the provided `layer_config`.
-        By default, only quantize layers in blocks.
-
-        Args:
-            layer_config (dict): The configuration dictionary for each layer containing various configuration options.
-
-        Returns:
-            bool: Returns True if there are quantized layers outside the blocks (e.g., lm-head),
-                  otherwise returns False.
-        """
-        # Get the names of layers in quantization blocks
-        supported_types = self.supported_types
-        layers_in_blocks = get_layer_names_in_block(
-            model, supported_types, self.quant_block_list, self.inner_supported_types
-        )
-        # Process regex in layer_config
-        all_supported_layer_names = []
-        # List of configuration keys
-        keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype",)
-
-        for n, m in model.named_modules():
-            # Delete previous configuration to avoid conflicts with prior tuning
-            for key in keys:
-                if hasattr(m, key):
-                    delattr(m, key)
-
-            if not isinstance(m, supported_types) and m.__class__.__name__ not in self.inner_supported_types:
-                continue
-            all_supported_layer_names.append(n)
-
-        names_in_layer_config = list(layer_config.keys())
-        for name in names_in_layer_config:
-            if name in all_supported_layer_names:
-                continue
-            matched_names = []
-            for layer_name in all_supported_layer_names:
-                if re.search(re.compile(name), layer_name) is not None:
-                    matched_names.append(layer_name)
-            if len(matched_names) > 0:
-                val = layer_config[name]
-                layer_config.pop(name)
-                for match_name in matched_names:
-                    layer_config[match_name] = val
-            else:
-                tmp_m = get_module(model, name)
-                if not isinstance(tmp_m, torch.nn.Embedding):  # TODO not good code style
-                    raise ValueError(f"key {name} in layer_config is invalid, please have a double check")
-
-        has_qlayer_outside_block = False  # Flag to track if there are quantized layers outside blocks (e.g., lm-head)
-
-        # Iterate through all modules in the model
-        is_gguf = hasattr(self, "formats") and any("gguf" in format_ for format_ in self.formats)
-        for n, m in model.named_modules():
-            # Skip unsupported types
-            if type(m) not in supported_types and m.__class__.__name__ not in self.inner_supported_types:
-                if n in self.layer_config:
-                    if not isinstance(m, torch.nn.Embedding):
-                        logger.warning(f"{n} is not supported, layer_config {n}: {layer_config[n]} will be ignored.")
-                        layer_config.pop(n)
-                        continue
-                    if not is_gguf:
-                        if not check_to_quantized(layer_config[n]):
-                            layer_config.pop(n)
-                            continue
-                else:
-                    continue
-
-            # If the layer is not in the config and is part of a quantization block, use default configuration
-            if n not in layer_config.keys() and n in layers_in_blocks:
-                layer_config[n] = {}
-                for key in keys:
-                    layer_config[n][key] = getattr(self, key)
-
-            # If the layer is partially configured, fill in missing values
-            elif n in layer_config.keys():
-                if "data_type" in layer_config[n] and "bits" not in layer_config[n]:
-                    tmp_bits = infer_bits_by_data_type(layer_config[n]["data_type"])
-                    if tmp_bits is not None and tmp_bits != self.bits:
-                        logger.warning(
-                            f"'data_type' do not match the specified 'bits' setting for {n}."
-                            f" Resetting 'bits' to {tmp_bits}."
-                        )
-                        layer_config[n]["bits"] = tmp_bits
-                if "act_data_type" in layer_config[n] and "act_bits" not in layer_config[n]:
-                    tmp_bits = infer_bits_by_data_type(layer_config[n]["act_data_type"])
-                    if tmp_bits is not None and tmp_bits != self.act_bits:
-                        logger.warning(
-                            f"'act_data_type' do not match the specified 'act_bits' setting for {n}."
-                            f" Resetting 'act_bits' to {tmp_bits}."
-                        )
-                        layer_config[n]["act_bits"] = tmp_bits
-
-                for key in keys:
-                    if key not in layer_config[n].keys():
-                        layer_config[n][key] = getattr(self, key)
-                layer_config[n]["fixed_by_user"] = True
-
-            # If the layer is not in the config and not part of a quantization block,
-            # use default configuration and set specific values
-            else:
-                layer_config[n] = {}
-                for key in keys:
-                    layer_config[n][key] = getattr(self, key)
-                layer_config[n]["bits"] = 16
-                layer_config[n]["act_bits"] = 16
-
-            if n in layers_in_blocks:
-                layer_config[n]["in_blocks"] = True
-            else:
-                layer_config[n]["in_blocks"] = False
-
-            # If the layer is outside a block and requires quantization, mark it as a quantized layer outside the block
-            if (
-                n not in layers_in_blocks
-                and check_to_quantized(layer_config[n])
-                and not isinstance(m, torch.nn.Embedding)
-            ):
-                has_qlayer_outside_block = True
-
-            in_features, out_features = get_layer_features(m)
-            if in_features <= layer_config[n]["group_size"]:
-                layer_config[n]["group_size"] = -1
-
-            # Apply the configuration to the corresponding layer in the model
-            for key in keys:
-                setattr(m, key, layer_config[n][key])
-        need_to_quantize_lm_head = self._check_need_to_quantize_lm_head_embedding()
-        if need_to_quantize_lm_head:
-            has_qlayer_outside_block = True
-
-        # Return whether there are quantized layers outside the blocks
-        return has_qlayer_outside_block
-
     @torch.no_grad()
     def _get_block_outputs(
         self,
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 97a3cdf02..f6ca0cc98 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -16,7 +16,7 @@
 from dataclasses import dataclass, fields
 from typing import Iterable, Optional, Union
 
-__all__ = ["QuantizationScheme", "is_gguf_scheme", "preset_name_to_scheme", "AutoScheme"]
+__all__ = ["QuantizationScheme", "get_gguf_scheme", "preset_name_to_scheme", "AutoScheme"]
 
 
 @dataclass
@@ -236,15 +236,15 @@ def is_preset_scheme(name: str) -> bool:
     PRESET_SCHEMES[key.upper()] = QuantizationScheme.from_dict(value)
 
 
-def is_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> bool:
+def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> bool:
     if isinstance(scheme, str) and scheme.upper().startswith("GGUF"):
         return True
     for key, val in PRESET_SCHEMES.items():
         if not key.upper().startswith("GGUF"):
             continue
         if val == scheme:
-            return True
-    return False
+            return key
+    return None
 
 
 @dataclass
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 575b8e3e8..3d35d303e 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -766,8 +766,9 @@ def check_memory_availability(device, inputs, weight, org_seqlen, org_bs):
 
 
 def get_layer_names_in_block(
-    model, supported_types=(torch.nn.Linear, transformers.pytorch_utils.Conv1D), quant_block_list=None, class_names=None
-):
+    model:torch.nn.Module, supported_types=(torch.nn.Linear, transformers.pytorch_utils.Conv1D),
+        quant_block_list:list=None, class_names:tuple=None
+) -> list[str]:
     """Retrieves the names of layers within each block of the model.
 
     Returns:
@@ -778,7 +779,7 @@ def get_layer_names_in_block(
         class_names = []
     for n, m in model.named_modules():
         if type(m) in supported_types or (class_names is not None and m.__class__.__name__ in class_names):
-            m.tmp_name = n
+            m.backup_name = n
     layers_in_block = []
     if bool(quant_block_list):
         all_blocks = quant_block_list
@@ -788,8 +789,9 @@ def get_layer_names_in_block(
         for block_name in block_names:
             block = get_module(model, block_name)
             for n, m in block.named_modules():
-                if hasattr(m, "tmp_name"):
-                    layers_in_block.append(m.tmp_name)
+                if hasattr(m, "backup_name"):
+                    layers_in_block.append(m.backup_name)
+                    delattr(m, "backup_name")
     return layers_in_block
 
 
@@ -1840,9 +1842,9 @@ def _gguf_type_fallback(gguf_type):
 
 
 ##https://github.com/ggml-org/llama.cpp/blob/9e31bec4fd53634c9e5b04650488a09a055f5dab/src/llama-quant.cpp#L129
-def get_layer_config_by_gguf_format(layer_config, gguf_format, model, model_type=ModelType.TEXT):
-    # TODO: support for other format later
-    target_gguf_format = next((fmt for fmt in gguf_format if fmt != "fake"), None)
+def get_layer_config_by_gguf_format(layer_config, target_gguf_format:str, model, model_type=ModelType.TEXT):
+    # # TODO: support for other format later
+    # target_gguf_format = next((fmt for fmt in gguf_format if fmt != "fake"), None)
 
     import gguf  # pylint: disable=E0401
 

From f027801f450d8036e4a98d09a4b6cc3826a7fb21 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 29 Sep 2025 06:33:01 +0000
Subject: [PATCH 22/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__main__.py         |  1 -
 auto_round/compressors/base.py | 78 ++++++++++++++++------------------
 auto_round/utils.py            |  8 ++--
 3 files changed, 42 insertions(+), 45 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 43f55a050..97e3eb6ff 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -478,7 +478,6 @@ def tune(args):
     #     layer_config[item[0]] = {}
     #     layer_config[item[0]]["bits"] = item[1]
 
-
     autoround: BaseCompressor = AutoRound(
         model=model_name,
         scheme=scheme,
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 6178623f0..c5928da60 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -35,7 +35,7 @@
 from auto_round.export.export_to_gguf.config import GGUF_CONFIG, GGUF_INNER_CONFIG, ModelType
 from auto_round.logger import logger
 from auto_round.low_cpu_mem.utils import get_layers_before_block
-from auto_round.schemes import AutoScheme, QuantizationScheme, preset_name_to_scheme, get_gguf_scheme
+from auto_round.schemes import AutoScheme, QuantizationScheme, get_gguf_scheme, preset_name_to_scheme
 from auto_round.sign_sgd import SignSGD
 from auto_round.special_model_handler import _handle_moe_model
 from auto_round.utils import (
@@ -414,18 +414,18 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
     def _prepare_layer_config(
-            self,
-            model: torch.nn.Module,
-            layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
-            default_scheme: "QuantizationScheme",
-            default_scale_dtype: torch.dtype | str,
-            supported_types: tuple,
-            inner_supported_types: tuple,
-            quant_block_list=None,
-            fp_layers: str = "",
-            quant_lm_head: bool = False,
-            enable_gguf_official_mixed: bool = True,
-            is_mllm: bool = False,
+        self,
+        model: torch.nn.Module,
+        layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+        default_scheme: "QuantizationScheme",
+        default_scale_dtype: torch.dtype | str,
+        supported_types: tuple,
+        inner_supported_types: tuple,
+        quant_block_list=None,
+        fp_layers: str = "",
+        quant_lm_head: bool = False,
+        enable_gguf_official_mixed: bool = True,
+        is_mllm: bool = False,
     ) -> tuple[dict, bool]:
         """
         Normalize, validate, and expand layer-specific quantization configs.
@@ -452,8 +452,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
                 invalid = set(item) - set(scheme_keys)
                 if invalid:
                     raise ValueError(
-                        f"Invalid keys {invalid} in layer_config for '{layer_name}'. "
-                        f"Allowed keys: {scheme_keys}"
+                        f"Invalid keys {invalid} in layer_config for '{layer_name}'. " f"Allowed keys: {scheme_keys}"
                     )
                 config = dict(item)
             else:
@@ -472,10 +471,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
 
         # 1. fp_layers -> force 16
         for name in get_fp_layer_names(self.model, fp_layers):
-            layer_config[name] = {
-                "bits": 16, "act_bits": 16,
-                "data_type": "float", "act_data_type": "float"
-            }
+            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
 
         # 2. normalize
         layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
@@ -528,17 +524,15 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         # 7. lm_head
         lm_head_name = get_lm_head_name(model)
         tied_lm_head = False
-        if (
-            hasattr(model, "config")
-            and model.config.tie_word_embeddings
-            and hasattr(model, "_tied_weights_keys")
-        ):
-            tied_keys =model._tied_weights_keys
+        if hasattr(model, "config") and model.config.tie_word_embeddings and hasattr(model, "_tied_weights_keys"):
+            tied_keys = model._tied_weights_keys
             if lm_head_name in tied_keys:
-                tied_lm_head=True
+                tied_lm_head = True
         if quant_lm_head and tied_lm_head:
-            quant_lm_head=False
-            logger.warning("reset `quant_lm_head` to false as quantizing lm_head with tied weights has not been supported currently")
+            quant_lm_head = False
+            logger.warning(
+                "reset `quant_lm_head` to false as quantizing lm_head with tied weights has not been supported currently"
+            )
 
         if lm_head_name not in layer_config and quant_lm_head:
             layer_config[lm_head_name] = default_dict.copy()
@@ -589,8 +583,6 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         dispatch_layer_config(layer_config)
         return layer_config, has_qlayer_outside_block
 
-
-
     def _parse_layer_config(
         self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers: str
     ) -> None:
@@ -651,7 +643,7 @@ def _parse_layer_config(
             if key not in lm_head_layer_config:
                 lm_head_layer_config[key] = getattr(self, key)
 
-    def  _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
+    def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
         if isinstance(scheme, QuantizationScheme):
             scheme = asdict(scheme)
@@ -1023,7 +1015,6 @@ def remove_duplicates(lst):
                     )
                     formats[i] = gguf_format_name.lower()
 
-
         _gguf_args_check(self, formats, model_type=ModelType.TEXT)
         if self.mllm:
             _gguf_args_check(self, formats, model_type=ModelType.MMPROJ)
@@ -1033,8 +1024,6 @@ def remove_duplicates(lst):
                 self.scheme = preset_name_to_scheme(f)
                 break
 
-
-
         for format_ in formats:
             if format_ not in SUPPORTED_FORMATS:
                 logger.error(f"Unsupported format {format_}, please choose from {SUPPORTED_FORMATS}")
@@ -1518,7 +1507,6 @@ def get_imatrix_hook(module, input, output):
             for hook in hooks:
                 hook.remove()
 
-
     def _quantize_layer_via_rtn(self, name: str) -> None:
         """Quantizes a layer using RTN (Round-To-Nearest) if available.
 
@@ -1818,7 +1806,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         Returns:
         The quantized model and layer configurations.
         """
-        for n, m in self.model.named_modules(): # TODO check if could removed
+        for n, m in self.model.named_modules():  # TODO check if could removed
             m.tmp_name = n
         self._check_compatibility()
         formats = self.formats if hasattr(self, "formats") else None
@@ -1827,11 +1815,19 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         self.model = _handle_moe_model(self.model, formats=formats)
         # self.has_qlayer_outside_block = self._set_layerwise_config(self.model, self.layer_config)
         # TODO check scale_dtype
-        self.layer_config, self.has_qlayer_outside_block = (
-            self._prepare_layer_config(self.model, self.layer_config,self.scheme, self.scale_dtype,
-                                       self.supported_types,self.inner_supported_types,self.quant_block_list,
-                                       self.fp_layers,self.quant_lm_head,
-                                       enable_gguf_official_mixed=True,is_mllm=self.mllm))
+        self.layer_config, self.has_qlayer_outside_block = self._prepare_layer_config(
+            self.model,
+            self.layer_config,
+            self.scheme,
+            self.scale_dtype,
+            self.supported_types,
+            self.inner_supported_types,
+            self.quant_block_list,
+            self.fp_layers,
+            self.quant_lm_head,
+            enable_gguf_official_mixed=True,
+            is_mllm=self.mllm,
+        )
 
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 3d35d303e..cac86e397 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -766,8 +766,10 @@ def check_memory_availability(device, inputs, weight, org_seqlen, org_bs):
 
 
 def get_layer_names_in_block(
-    model:torch.nn.Module, supported_types=(torch.nn.Linear, transformers.pytorch_utils.Conv1D),
-        quant_block_list:list=None, class_names:tuple=None
+    model: torch.nn.Module,
+    supported_types=(torch.nn.Linear, transformers.pytorch_utils.Conv1D),
+    quant_block_list: list = None,
+    class_names: tuple = None,
 ) -> list[str]:
     """Retrieves the names of layers within each block of the model.
 
@@ -1842,7 +1844,7 @@ def _gguf_type_fallback(gguf_type):
 
 
 ##https://github.com/ggml-org/llama.cpp/blob/9e31bec4fd53634c9e5b04650488a09a055f5dab/src/llama-quant.cpp#L129
-def get_layer_config_by_gguf_format(layer_config, target_gguf_format:str, model, model_type=ModelType.TEXT):
+def get_layer_config_by_gguf_format(layer_config, target_gguf_format: str, model, model_type=ModelType.TEXT):
     # # TODO: support for other format later
     # target_gguf_format = next((fmt for fmt in gguf_format if fmt != "fake"), None)
 

From c6b78c6ad7276a2ba207d506e6857ba282b507ea Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 14:56:09 +0800
Subject: [PATCH 23/88] tiny change

---
 auto_round/compressors/base.py | 41 +++++++++++-----------------------
 1 file changed, 13 insertions(+), 28 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index c5928da60..931f18197 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -413,10 +413,10 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-    def _prepare_layer_config(
+    def _set_layer_config(
         self,
         model: torch.nn.Module,
-        layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+        layer_config: dict[str, str | dict | "QuantizationScheme"],
         default_scheme: "QuantizationScheme",
         default_scale_dtype: torch.dtype | str,
         supported_types: tuple,
@@ -523,15 +523,15 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
 
         # 7. lm_head
         lm_head_name = get_lm_head_name(model)
-        tied_lm_head = False
-        if hasattr(model, "config") and model.config.tie_word_embeddings and hasattr(model, "_tied_weights_keys"):
-            tied_keys = model._tied_weights_keys
-            if lm_head_name in tied_keys:
-                tied_lm_head = True
-        if quant_lm_head and tied_lm_head:
+        tie_word_embeddings = False
+        if hasattr(model, "config") and hasattr(model.config, "tie_word_embeddings"):
+            tie_word_embeddings = model.config.tie_word_embeddings
+
+        if quant_lm_head and tie_word_embeddings:
             quant_lm_head = False
             logger.warning(
-                "reset `quant_lm_head` to false as quantizing lm_head with tied weights has not been supported currently"
+                "reset `quant_lm_head` to false as quantizing "
+                "lm_head with tied weights has not been supported currently"
             )
 
         if lm_head_name not in layer_config and quant_lm_head:
@@ -566,7 +566,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
             return layer_config, has_qlayer_outside_block
 
         # embed + lm_head defaults for gguf
-        if lm_head_name not in layer_config and not tied_lm_head:
+        if lm_head_name not in layer_config and not tie_word_embeddings:
             cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["lm_head"]]
             cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
             layer_config[lm_head_name] = cfg
@@ -1813,9 +1813,9 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         # It is best to modify the model structure in the quantize function and check the format,
         # because it may cause the gguf format to not be exported normally.
         self.model = _handle_moe_model(self.model, formats=formats)
-        # self.has_qlayer_outside_block = self._set_layerwise_config(self.model, self.layer_config)
+
         # TODO check scale_dtype
-        self.layer_config, self.has_qlayer_outside_block = self._prepare_layer_config(
+        self.layer_config, self.has_qlayer_outside_block = self._set_layer_config(
             self.model,
             self.layer_config,
             self.scheme,
@@ -1832,21 +1832,6 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
         else:
-            only_gguf = True
-            for format_ in self.formats:
-                if not ("gguf" in format_ or "fake" in format_):
-                    only_gguf = False
-                    break
-            if len(self.formats) == 1 and self.formats[0] == "fake":
-                only_gguf = False
-            # if only_gguf:
-            #     self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
-            #         self.layer_config, self.formats, self.model, model_type=ModelType.TEXT
-            #     )
-            #     if self.mllm:
-            #         self.layer_config, gguf_format_config = get_layer_config_by_gguf_format(
-            #             self.layer_config, self.formats, self.model, model_type=ModelType.MMPROJ
-            #         )
             # Determine if immediate packing is required
             formats = self.formats
             if (
@@ -1958,7 +1943,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         cost_time = end_time - self.start_time
         logger.info(f"quantization tuning time {cost_time}")
 
-        ## dump a summary
+        # Dump a summary
         quantized_layers = []
         unquantized_layers = []
         for n, m in self.model.named_modules():

From 1b9f24e8fde62ffa7f0e0e8321b69ae3c6d6479e Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 14:57:58 +0800
Subject: [PATCH 24/88] tiny fix

---
 auto_round/schemes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index f6ca0cc98..8dde95430 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -236,7 +236,7 @@ def is_preset_scheme(name: str) -> bool:
     PRESET_SCHEMES[key.upper()] = QuantizationScheme.from_dict(value)
 
 
-def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> bool:
+def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
     if isinstance(scheme, str) and scheme.upper().startswith("GGUF"):
         return True
     for key, val in PRESET_SCHEMES.items():

From 2c0075ae48c98d095ef68515af51f509c94af1be Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 15:11:58 +0800
Subject: [PATCH 25/88] tmp change

---
 auto_round/__main__.py         | 2 +-
 auto_round/compressors/base.py | 6 ++++--
 auto_round/schemes.py          | 2 +-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 97e3eb6ff..a25fc5421 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -110,7 +110,7 @@ def __init__(self, *args, **kwargs):
 
         self.add_argument(
             "--scale_dtype",
-            default="fp16",
+            default=None,
             choices=["fp16", "float16", "bf16", "bfloat16", "fp32", "float32"],
             help="scale data type to use for quantization",
         )
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 931f18197..281efff46 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -202,6 +202,10 @@ def __init__(
             ... }
         """
         self.scheme = self._parse_and_set_scheme(scheme, kwargs)
+
+        gguf_scheme_name = get_gguf_scheme(self.scheme)
+        # GGUF uses fp32 scale dtype as default
+        scale_dtype = kwargs.pop("scale_dtype", "fp32") if gguf_scheme_name else kwargs.pop("scale_dtype", "fp16")
         # Extra/legacy kwargs for backward compatibility
         # Major version releases may pack them with extra configuration options
         amp = kwargs.pop("amp", True)
@@ -214,7 +218,6 @@ def __init__(
         sampler = kwargs.pop("sampler", "rand")
         not_use_best_mse = kwargs.pop("not_use_best_mse", False)
         dynamic_max_gap = kwargs.pop("dynamic_max_gap", -1)
-        scale_dtype = kwargs.pop("scale_dtype", "fp16")
         nblocks = kwargs.pop("nblocks", 1)
         low_cpu_mem_usage = kwargs.pop("low_cpu_mem_usage", False)
         to_quant_block_names: Union[str, list, None] = kwargs.pop("to_quant_block_names", None)
@@ -287,7 +290,6 @@ def __init__(
             self.device_map = None
         self._set_device_map_in_blocks(self.device_map)
 
-        # self._parse_layer_config(layer_config, fp_layers)  # Must place after model init
 
         self.to_quant_block_names = to_quant_block_names
 
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 8dde95430..c5513d79a 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -244,7 +244,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
             continue
         if val == scheme:
             return key
-    return None
+    return ""
 
 
 @dataclass

From 97198f07b6fe660e6fba8b63c224ddb7440441d1 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 15:40:49 +0800
Subject: [PATCH 26/88] tmp change

---
 auto_round/auto_schemes/utils.py   |  5 ++++
 auto_round/compressors/base.py     | 39 +++++++++---------------------
 auto_round/schemes.py              |  4 +--
 test/test_cuda/test_auto_scheme.py | 33 +++++++++++++++++++++++++
 4 files changed, 52 insertions(+), 29 deletions(-)
 create mode 100644 auto_round/auto_schemes/utils.py
 create mode 100644 test/test_cuda/test_auto_scheme.py

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
new file mode 100644
index 000000000..fdcd343e7
--- /dev/null
+++ b/auto_round/auto_schemes/utils.py
@@ -0,0 +1,5 @@
+def get_total_bits(model, layer_config):
+    pass
+
+def get_bits(layer):
+    pass
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 281efff46..8477b2ed7 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -201,7 +201,10 @@ def __init__(
             ...     # ...
             ... }
         """
-        self.scheme = self._parse_and_set_scheme(scheme, kwargs)
+        if isinstance(scheme, AutoScheme): #TODO  AutoScheme could also be patched by group_size, etc
+            self.scheme = self._parse_and_set_scheme(scheme.options[0], kwargs)
+        else:
+            self.scheme = self._parse_and_set_scheme(scheme, kwargs)
 
         gguf_scheme_name = get_gguf_scheme(self.scheme)
         # GGUF uses fp32 scale dtype as default
@@ -271,6 +274,12 @@ def __init__(
         self.tokenizer = tokenizer
         self.shared_cache_keys = get_shared_keys(self.model)
 
+        self.to_quant_block_names = to_quant_block_names
+        if not hasattr(self, "quant_block_list"):
+            all_blocks = get_block_names(model)
+            self.quant_block_list = find_matching_blocks(model, all_blocks, self.to_quant_block_names)
+
+
         if device is not None:
             logger.warning("`device` is deprecated, please use `device_map` instead")
 
@@ -290,9 +299,6 @@ def __init__(
             self.device_map = None
         self._set_device_map_in_blocks(self.device_map)
 
-
-        self.to_quant_block_names = to_quant_block_names
-
         # Set device, must place after model loading
         self._set_device(device_map)
 
@@ -342,27 +348,6 @@ def __init__(
         if self.static_kv_dtype is not None:
             logger.warning("The static kv is experimental and currently has limited support.")
 
-        # Model related
-        self.quantized = False
-        if isinstance(model, str):
-            model, tokenizer, low_cpu_mem_usage = llm_load_model(
-                model, device=device, low_cpu_mem_mode=low_cpu_mem_usage
-            )
-        elif tokenizer is None and iters > 0:
-            raise ValueError("A tokenizer must be set for non-str model input")
-        self.low_cpu_mem_usage = bool(low_cpu_mem_usage)
-        if unsupported_meta_device(model):
-            raise RuntimeError(
-                "AutoRound does not support parameters on meta device. "
-                "Please use more GPUs by setting `--device_map 0,1,2,3` or just place the model on CPU."
-            )
-        self.model = model.eval()
-        self.tokenizer = tokenizer
-        self.shared_cache_keys = get_shared_keys(self.model)
-        if not hasattr(self, "quant_block_list"):
-            all_blocks = get_block_names(model)
-            self.quant_block_list = find_matching_blocks(model, all_blocks, self.to_quant_block_names)
-
         self.scale_dtype = convert_dtype_str2torch(scale_dtype)
         self._set_amp_dtype()
         self.cache_device = torch.device("cpu") if self.low_gpu_mem_usage else self.device
@@ -418,7 +403,7 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
     def _set_layer_config(
         self,
         model: torch.nn.Module,
-        layer_config: dict[str, str | dict | "QuantizationScheme"],
+        layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
         default_scheme: "QuantizationScheme",
         default_scale_dtype: torch.dtype | str,
         supported_types: tuple,
@@ -558,7 +543,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         for cfg in layer_config.values():
             if "in_blocks" not in cfg:
                 cfg["in_blocks"] = False
-            # 如果 layer 不在 blocks 且需要量化，则标记存在 blocks 外的量化层
+            # mark layer outside block
             if not cfg["in_blocks"] and check_to_quantized(cfg):
                 has_qlayer_outside_block = True
 
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index c5513d79a..ee12607eb 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -249,7 +249,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 
 @dataclass
 class AutoScheme:
-    options: Optional[Iterable[QuantizationScheme]]
+    options: Optional[Iterable[QuantizationScheme|str]]
     target_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
-    method: str = "naive_pre"
+    method: str = "default"
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
new file mode 100644
index 000000000..4fd2e9c8b
--- /dev/null
+++ b/test/test_cuda/test_auto_scheme.py
@@ -0,0 +1,33 @@
+import copy
+import re
+import shutil
+import sys
+import unittest
+
+sys.path.insert(0, "../..")
+import torch
+import transformers
+from lm_eval.utils import make_table  # pylint: disable=E0401
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from auto_round import AutoRound, AutoRoundConfig,AutoScheme
+from auto_round.eval.evaluation import simple_evaluate, simple_evaluate_user_model
+from auto_round.testing_utils import require_autogptq, require_greater_than_050, require_greater_than_051
+
+class TestAutoScheme(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        self.save_dir = "./saved"
+        self.tasks = "lambada_openai"
+
+    @classmethod
+    def tearDownClass(self):
+        shutil.rmtree("./saved", ignore_errors=True)
+        shutil.rmtree("runs", ignore_errors=True)
+
+
+    def test_auto_scheme(self):
+        model_name = "facebook/opt-125m"
+        scheme = AutoScheme(target_bits=3, options=("W2A16","W4A16","BF16"))
+        ar = AutoRound(model_name=model_name,scheme=scheme)
+        ar.quantize_and_save(self.save_dir)

From 27b4b4da882966b06ee750fe93e5fe4db3694bde Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 29 Sep 2025 07:43:18 +0000
Subject: [PATCH 27/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/utils.py   | 16 ++++++++++++++++
 auto_round/compressors/base.py     |  3 +--
 auto_round/schemes.py              |  2 +-
 test/test_cuda/test_auto_scheme.py |  8 ++++----
 4 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index fdcd343e7..e01da9913 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -1,5 +1,21 @@
+# 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.
+
+
 def get_total_bits(model, layer_config):
     pass
 
+
 def get_bits(layer):
     pass
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 8477b2ed7..f7cd773d8 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -201,7 +201,7 @@ def __init__(
             ...     # ...
             ... }
         """
-        if isinstance(scheme, AutoScheme): #TODO  AutoScheme could also be patched by group_size, etc
+        if isinstance(scheme, AutoScheme):  # TODO  AutoScheme could also be patched by group_size, etc
             self.scheme = self._parse_and_set_scheme(scheme.options[0], kwargs)
         else:
             self.scheme = self._parse_and_set_scheme(scheme, kwargs)
@@ -279,7 +279,6 @@ def __init__(
             all_blocks = get_block_names(model)
             self.quant_block_list = find_matching_blocks(model, all_blocks, self.to_quant_block_names)
 
-
         if device is not None:
             logger.warning("`device` is deprecated, please use `device_map` instead")
 
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index ee12607eb..38bed87e1 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -249,7 +249,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 
 @dataclass
 class AutoScheme:
-    options: Optional[Iterable[QuantizationScheme|str]]
+    options: Optional[Iterable[QuantizationScheme | str]]
     target_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 4fd2e9c8b..6376e92c2 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -10,10 +10,11 @@
 from lm_eval.utils import make_table  # pylint: disable=E0401
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-from auto_round import AutoRound, AutoRoundConfig,AutoScheme
+from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 from auto_round.eval.evaluation import simple_evaluate, simple_evaluate_user_model
 from auto_round.testing_utils import require_autogptq, require_greater_than_050, require_greater_than_051
 
+
 class TestAutoScheme(unittest.TestCase):
     @classmethod
     def setUpClass(self):
@@ -25,9 +26,8 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-
     def test_auto_scheme(self):
         model_name = "facebook/opt-125m"
-        scheme = AutoScheme(target_bits=3, options=("W2A16","W4A16","BF16"))
-        ar = AutoRound(model_name=model_name,scheme=scheme)
+        scheme = AutoScheme(target_bits=3, options=("W2A16", "W4A16", "BF16"))
+        ar = AutoRound(model_name=model_name, scheme=scheme)
         ar.quantize_and_save(self.save_dir)

From 2d3095a05368e3c082861df49d0cff4c0b7855c2 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 16:36:52 +0800
Subject: [PATCH 28/88] update

---
 auto_round/auto_schemes/gen_scheme.py |  19 ++
 auto_round/compressors/base.py        | 261 +++-----------------------
 auto_round/schemes.py                 |   2 +-
 auto_round/utils.py                   | 177 ++++++++++++++++-
 test/test_cuda/test_auto_scheme.py    |  11 +-
 5 files changed, 224 insertions(+), 246 deletions(-)
 create mode 100644 auto_round/auto_schemes/gen_scheme.py

diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
new file mode 100644
index 000000000..badf39742
--- /dev/null
+++ b/auto_round/auto_schemes/gen_scheme.py
@@ -0,0 +1,19 @@
+from typing import Union, Iterable
+
+import torch
+
+from auto_round import AutoScheme
+
+
+class GenScheme:
+    def __init__(self,
+                 auto_scheme: AutoScheme,
+                 model: torch.nn.Module,
+                 quant_layer_names: Iterable[str],
+                 fixed_layer_scheme:dict[str, dict],
+                 scale_dtype: str = "fp16",
+                 dataset="pile-10k"
+                 ):
+        pass
+
+
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index f7cd773d8..495cf3d04 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -93,7 +93,7 @@
     set_module,
     to_device,
     to_dtype,
-    unsupported_meta_device,
+    unsupported_meta_device, set_layer_config,
 )
 from auto_round.wrapper import WrapperLinear, WrapperMultiblock, unwrapper_block, unwrapper_layer, wrapper_block
 
@@ -236,6 +236,9 @@ def __init__(
         self.mem_per_param_scale = kwargs.pop("mem_per_param_scale", None)
         self.fp_layers = kwargs.pop("fp_layers", "")
         self.layer_config = layer_config
+        self.supported_types = SUPPORTED_LAYER_TYPES
+        self.inner_supported_types = INNER_SUPPORTED_LAYER_TYPES
+        self.scale_dtype = convert_dtype_str2torch(scale_dtype)
 
         if kwargs:
             logger.warning(f"unrecognized keys {list(kwargs.keys())} were passed. Please check them.")
@@ -285,6 +288,28 @@ def __init__(
         if device_map is None:
             device_map = 0
 
+        if isinstance(scheme, AutoScheme):
+            if self.mllm:
+                logger.info("AutoScheme with MLLM is not supported yet.")
+                sys.exit(1)
+            layer_config,_ = set_layer_config(self.model,
+            self.layer_config,
+            self.scheme,
+            self.scale_dtype,
+            self.supported_types,
+            self.inner_supported_types,
+            self.quant_block_list,
+            self.fp_layers,
+            self.quant_lm_head,
+            enable_gguf_official_mixed=False,
+            is_mllm=self.mllm)
+            quant_layer_names = layer_config.keys()
+            fixed_layer_scheme = {k: v for k, v in layer_config.items() if v.get("fixed_by_user", False)}
+            # mainly using quant_layers and fixed by users
+            from auto_round.auto_schemes.gen_scheme import GenScheme
+            gen_scheme = GenScheme(scheme,self.model,quant_layer_names,fixed_layer_scheme, self.scale_dtype, self.dataset)
+
+
         # Set device, must place after model loading
         self._set_device(device_map)
 
@@ -347,7 +372,6 @@ def __init__(
         if self.static_kv_dtype is not None:
             logger.warning("The static kv is experimental and currently has limited support.")
 
-        self.scale_dtype = convert_dtype_str2torch(scale_dtype)
         self._set_amp_dtype()
         self.cache_device = torch.device("cpu") if self.low_gpu_mem_usage else self.device
         if self.act_bits <= 8 and self.amp_dtype == torch.float16:
@@ -359,8 +383,6 @@ def __init__(
             logger.info(f"using {self.model.dtype} for quantization tuning")
 
         # Some helpers
-        self.supported_types = SUPPORTED_LAYER_TYPES
-        self.inner_supported_types = INNER_SUPPORTED_LAYER_TYPES
         if "hpu" in str(self.device):
             self.inner_supported_types = tuple(x for x in INNER_SUPPORTED_LAYER_TYPES if x != "FP8Linear")
         self.batch_dim = None
@@ -399,235 +421,6 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-    def _set_layer_config(
-        self,
-        model: torch.nn.Module,
-        layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
-        default_scheme: "QuantizationScheme",
-        default_scale_dtype: torch.dtype | str,
-        supported_types: tuple,
-        inner_supported_types: tuple,
-        quant_block_list=None,
-        fp_layers: str = "",
-        quant_lm_head: bool = False,
-        enable_gguf_official_mixed: bool = True,
-        is_mllm: bool = False,
-    ) -> tuple[dict, bool]:
-        """
-        Normalize, validate, and expand layer-specific quantization configs.
-        Returns (final_layer_config, has_quant_layer_outside_block)
-        """
-
-        from auto_round.schemes import get_gguf_scheme
-
-        # ---- helpers -------------------------------------------------
-        def dispatch_layer_config(layer_config: dict[str, dict]) -> None:
-            """Assign scheme values as attributes to matched modules."""
-            for layer_name, scheme in layer_config.items():
-                module = get_module(model, layer_name)
-                for attr, value in scheme.items():
-                    setattr(module, attr, value)
-
-        def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str) -> dict:
-            """Convert config entry into dict and validate keys."""
-            if isinstance(item, str):
-                config = asdict(preset_name_to_scheme(item.upper()))
-            elif isinstance(item, QuantizationScheme):
-                config = asdict(item)
-            elif isinstance(item, dict):
-                invalid = set(item) - set(scheme_keys)
-                if invalid:
-                    raise ValueError(
-                        f"Invalid keys {invalid} in layer_config for '{layer_name}'. " f"Allowed keys: {scheme_keys}"
-                    )
-                config = dict(item)
-            else:
-                raise TypeError(
-                    f"Unsupported type for layer_config[{layer_name}]: {type(item)}. "
-                    f"Expected str, dict, or QuantizationScheme."
-                )
-            # Clean up
-            config = {k: v for k, v in config.items() if v is not None}
-            config["fixed_by_user"] = True
-            return config
-
-        # ---- main logic ----------------------------------------------
-        scheme_keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype",)
-        layer_config = copy.deepcopy(layer_config) or {}
-
-        # 1. fp_layers -> force 16
-        for name in get_fp_layer_names(self.model, fp_layers):
-            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
-
-        # 2. normalize
-        layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
-
-        # 3. infer missing bits
-        for cfg in layer_config.values():
-            if "data_type" in cfg and "bits" not in cfg:
-                if (b := infer_bits_by_data_type(cfg["data_type"])) is not None:
-                    cfg["bits"] = b
-            if "act_data_type" in cfg and "act_bits" not in cfg:
-                if (b := infer_bits_by_data_type(cfg["act_data_type"])) is not None:
-                    cfg["act_bits"] = b
-
-        # 4. fill defaults
-        default_dict = asdict(default_scheme)
-        default_dict["scale_dtype"] = default_scale_dtype
-        for cfg in layer_config.values():
-            for key in scheme_keys:
-                cfg.setdefault(key, default_dict.get(key))
-
-        # 5. collect supported modules
-        gguf_name = get_gguf_scheme(default_scheme)
-        if gguf_name and torch.nn.Embedding not in supported_types:
-            supported_types = (*supported_types, torch.nn.Embedding)
-
-        all_layer_names, embedding_layer_names = [], []
-        for n, m in model.named_modules():
-            # cleanup stale attributes
-            for key in scheme_keys:
-                if hasattr(m, key):
-                    delattr(m, key)
-            if type(m) not in supported_types and m.__class__.__name__ not in inner_supported_types:
-                continue
-            all_layer_names.append(n)
-            if isinstance(m, torch.nn.Embedding):
-                embedding_layer_names.append(n)
-
-        # 6. expand regex configs
-        for name in list(layer_config.keys()):
-            if name in all_layer_names:
-                continue
-            regex = re.compile(name)
-            matched = [ln for ln in all_layer_names if regex.search(ln)]
-            if not matched:
-                raise ValueError(f"Invalid regex '{name}' in layer_config, no match found.")
-            val = layer_config.pop(name)
-            for match in matched:
-                layer_config[match] = val
-
-        # 7. lm_head
-        lm_head_name = get_lm_head_name(model)
-        tie_word_embeddings = False
-        if hasattr(model, "config") and hasattr(model.config, "tie_word_embeddings"):
-            tie_word_embeddings = model.config.tie_word_embeddings
-
-        if quant_lm_head and tie_word_embeddings:
-            quant_lm_head = False
-            logger.warning(
-                "reset `quant_lm_head` to false as quantizing "
-                "lm_head with tied weights has not been supported currently"
-            )
-
-        if lm_head_name not in layer_config and quant_lm_head:
-            layer_config[lm_head_name] = default_dict.copy()
-
-        # 8. enforce shape divisibility for int weight-only
-        if default_dict["data_type"] == "int" and default_dict["act_bits"] >= 16 and not gguf_name:
-            for n, m in model.named_modules():
-                if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
-                    if m.weight.shape[0] % 32 or m.weight.shape[1] % 32:
-                        layer_config.setdefault(n, default_dict.copy())
-                        layer_config[n].update({"bits": 16, "data_type": "fp", "fixed_by_user": True})
-                        logger.warning_once(f"{n} skipped quantization (shape not divisible by 32).")
-
-        # 9. block layers: mark as in_blocks=True
-        for name in get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types):
-            cfg = layer_config.setdefault(name, default_dict.copy())
-            cfg["in_blocks"] = True
-
-        # ---- restore: ensure missing in_blocks are set to False and compute flag ----
-        has_qlayer_outside_block = False
-        for cfg in layer_config.values():
-            if "in_blocks" not in cfg:
-                cfg["in_blocks"] = False
-            # mark layer outside block
-            if not cfg["in_blocks"] and check_to_quantized(cfg):
-                has_qlayer_outside_block = True
-
-        # 10. GGUF handling
-        if not gguf_name:
-            dispatch_layer_config(layer_config)
-            return layer_config, has_qlayer_outside_block
-
-        # embed + lm_head defaults for gguf
-        if lm_head_name not in layer_config and not tie_word_embeddings:
-            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["lm_head"]]
-            cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
-            layer_config[lm_head_name] = cfg
-            has_qlayer_outside_block = True
-        for emd_name in embedding_layer_names:
-            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
-            cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
-            layer_config[emd_name] = cfg
-
-        if enable_gguf_official_mixed:
-            model_type = ModelType.MMPROJ if is_mllm else ModelType.TEXT
-            layer_config, _ = get_layer_config_by_gguf_format(layer_config, gguf_name.lower(), model, model_type)
-
-        dispatch_layer_config(layer_config)
-        return layer_config, has_qlayer_outside_block
-
-    def _parse_layer_config(
-        self, layer_config: dict[str, Union[str, dict, QuantizationScheme]], fp_layers: str
-    ) -> None:
-        """Parse and set the layer-wise quantization configuration."""
-        not_quantize_layer_names = get_fp_layer_names(self.model, fp_layers)
-        if len(not_quantize_layer_names) > 0:
-            logger.info(f"{not_quantize_layer_names} will not be quantized.")
-        if layer_config is None:
-            layer_config = {}
-        for name in not_quantize_layer_names:
-            layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float"}
-
-        # Some other quantization configs
-        self.layer_config = copy.deepcopy(layer_config) if layer_config is not None else {}
-        scheme_keys = {f.name for f in fields(QuantizationScheme)}
-
-        for key, item in self.layer_config.items():
-            if isinstance(item, str):
-                config = asdict(preset_name_to_scheme(item.upper()))
-            elif isinstance(item, QuantizationScheme):
-                config = asdict(item)
-            elif isinstance(item, dict):
-                invalid_keys = set(item) - scheme_keys
-                if invalid_keys:
-                    raise ValueError(
-                        f"Invalid keys {invalid_keys} in layer_config for layer '{key}', "
-                        f"only {scheme_keys} are supported"
-                    )
-                config = dict(item)
-
-            # Drop None values
-            config = {k: v for k, v in config.items() if v is not None}
-            self.layer_config[key] = config
-
-        if not self.quant_lm_head or (isinstance(self.scheme, str) and self.scheme.lower().startswith("gguf")):
-            return
-        for n, _ in self.model.named_modules():
-            lm_head_layer_name = n
-
-        if (
-            hasattr(self.model, "config")
-            and self.model.config.tie_word_embeddings
-            and hasattr(self.model, "_tied_weights_keys")
-        ):
-            tied_keys = self.model._tied_weights_keys
-            for item in tied_keys:
-                if lm_head_layer_name in item:  # TODO extend to encoder-decoder layer, seq classification model
-                    self.quant_lm_head = False
-                    logger.warning(
-                        "reset `quant_lm_head` to `False` as quantizing lm_head with tied weights has not been "
-                        "supported currently"
-                    )
-                    break
-
-        lm_head_layer_config = self.layer_config[lm_head_layer_name] if lm_head_layer_name in self.layer_config else {}
-
-        for key in scheme_keys:
-            if key not in lm_head_layer_config:
-                lm_head_layer_config[key] = getattr(self, key)
 
     def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
@@ -1801,7 +1594,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         self.model = _handle_moe_model(self.model, formats=formats)
 
         # TODO check scale_dtype
-        self.layer_config, self.has_qlayer_outside_block = self._set_layer_config(
+        self.layer_config, self.has_qlayer_outside_block = set_layer_config(
             self.model,
             self.layer_config,
             self.scheme,
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 38bed87e1..cf7d4d433 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -250,6 +250,6 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 @dataclass
 class AutoScheme:
     options: Optional[Iterable[QuantizationScheme | str]]
-    target_bits: float
+    avg_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
diff --git a/auto_round/utils.py b/auto_round/utils.py
index cac86e397..92e54a3ba 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -21,7 +21,7 @@
 import re
 import sys
 from collections import UserDict
-from dataclasses import fields
+from dataclasses import fields, asdict
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -35,7 +35,7 @@
 
 from auto_round.export.export_to_gguf.config import GGML_QUANT_SIZES, GGUF_CONFIG, GGUF_INNER_CONFIG, QK_K, ModelType
 from auto_round.logger import logger
-from auto_round.schemes import QuantizationScheme
+from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
 
 SHARED_CACHE_KEYS = ("position_ids", "cache_position", "position_embeddings")
 
@@ -2742,3 +2742,176 @@ def is_mllm_model(model_or_path: Union[str, torch.nn.Module]):
                 return True
 
     return False
+
+
+
+def set_layer_config(
+    model: torch.nn.Module,
+    layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
+    default_scheme: "QuantizationScheme",
+    default_scale_dtype: torch.dtype | str,
+    supported_types: tuple,
+    inner_supported_types: tuple,
+    quant_block_list=None,
+    fp_layers: str = "",
+    quant_lm_head: bool = False,
+    enable_gguf_official_mixed: bool = True,
+    is_mllm: bool = False,
+) -> tuple[dict, bool]:
+    """
+    Normalize, validate, and expand layer-specific quantization configs.
+    Returns (final_layer_config, has_quant_layer_outside_block)
+    """
+
+    from auto_round.schemes import get_gguf_scheme
+
+    # ---- helpers -------------------------------------------------
+    def dispatch_layer_config(layer_config: dict[str, dict]) -> None:
+        """Assign scheme values as attributes to matched modules."""
+        for layer_name, scheme in layer_config.items():
+            module = get_module(model, layer_name)
+            for attr, value in scheme.items():
+                setattr(module, attr, value)
+
+    def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str) -> dict:
+        """Convert config entry into dict and validate keys."""
+        if isinstance(item, str):
+            config = asdict(preset_name_to_scheme(item.upper()))
+        elif isinstance(item, QuantizationScheme):
+            config = asdict(item)
+        elif isinstance(item, dict):
+            invalid = set(item) - set(scheme_keys)
+            if invalid:
+                raise ValueError(
+                    f"Invalid keys {invalid} in layer_config for '{layer_name}'. " f"Allowed keys: {scheme_keys}"
+                )
+            config = dict(item)
+        else:
+            raise TypeError(
+                f"Unsupported type for layer_config[{layer_name}]: {type(item)}. "
+                f"Expected str, dict, or QuantizationScheme."
+            )
+        # Clean up
+        config = {k: v for k, v in config.items() if v is not None}
+        config["fixed_by_user"] = True
+        return config
+
+    # ---- main logic ----------------------------------------------
+    scheme_keys = tuple(f.name for f in fields(QuantizationScheme)) + ("scale_dtype",)
+    layer_config = copy.deepcopy(layer_config) or {}
+
+    # 1. fp_layers -> force 16
+    for name in get_fp_layer_names(model, fp_layers):
+        layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float","fixed_by_user":True}
+
+    # 2. normalize
+    layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
+
+    # 3. infer missing bits
+    for cfg in layer_config.values():
+        if "data_type" in cfg and "bits" not in cfg:
+            if (b := infer_bits_by_data_type(cfg["data_type"])) is not None:
+                cfg["bits"] = b
+        if "act_data_type" in cfg and "act_bits" not in cfg:
+            if (b := infer_bits_by_data_type(cfg["act_data_type"])) is not None:
+                cfg["act_bits"] = b
+
+    # 4. fill defaults
+    default_dict = asdict(default_scheme)
+    default_dict["scale_dtype"] = default_scale_dtype
+    for cfg in layer_config.values():
+        for key in scheme_keys:
+            cfg.setdefault(key, default_dict.get(key))
+
+    # 5. collect supported modules
+    gguf_name = get_gguf_scheme(default_scheme)
+    if gguf_name and torch.nn.Embedding not in supported_types:
+        supported_types = (*supported_types, torch.nn.Embedding)
+
+    all_layer_names, embedding_layer_names = [], []
+    for n, m in model.named_modules():
+        # cleanup stale attributes
+        for key in scheme_keys:
+            if hasattr(m, key):
+                delattr(m, key)
+        if type(m) not in supported_types and m.__class__.__name__ not in inner_supported_types:
+            continue
+        all_layer_names.append(n)
+        if isinstance(m, torch.nn.Embedding):
+            embedding_layer_names.append(n)
+
+    # 6. expand regex configs
+    for name in list(layer_config.keys()):
+        if name in all_layer_names:
+            continue
+        regex = re.compile(name)
+        matched = [ln for ln in all_layer_names if regex.search(ln)]
+        if not matched:
+            raise ValueError(f"Invalid '{name}' in layer_config, no match found.")
+        val = layer_config.pop(name)
+        for match in matched:
+            layer_config[match] = val
+
+    # 7. lm_head
+    lm_head_name = get_lm_head_name(model)
+    tie_word_embeddings = False
+    if hasattr(model, "config") and hasattr(model.config, "tie_word_embeddings"):
+        tie_word_embeddings = model.config.tie_word_embeddings
+
+    if quant_lm_head and tie_word_embeddings:
+        quant_lm_head = False
+        logger.warning(
+            "reset `quant_lm_head` to false as quantizing "
+            "lm_head with tied weights has not been supported currently"
+        )
+
+    if lm_head_name not in layer_config and quant_lm_head:
+        layer_config[lm_head_name] = default_dict.copy()
+
+    # 8. enforce shape divisibility for int weight-only
+    if default_dict["data_type"] == "int" and default_dict["act_bits"] >= 16 and not gguf_name:
+        for n, m in model.named_modules():
+            if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
+                if m.weight.shape[0] % 32 or m.weight.shape[1] % 32:
+                    layer_config.setdefault(n, default_dict.copy())
+                    layer_config[n].update({"bits": 16, "data_type": "fp", "fixed_by_user": True})
+                    logger.warning_once(f"{n} skipped quantization (shape not divisible by 32).")
+
+    # 9. block layers: mark as in_blocks=True
+    for name in get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types):
+        if name not in layer_config:
+            layer_config[name] = default_dict.copy()
+            layer_config[name]["fixed_by_user"]=False
+        layer_config[name]["in_blocks"] = True
+
+    # ---- restore: ensure missing in_blocks are set to False and compute flag ----
+    has_qlayer_outside_block = False
+    for cfg in layer_config.values():
+        if "in_blocks" not in cfg:
+            cfg["in_blocks"] = False
+        # mark layer outside block
+        if not cfg["in_blocks"] and check_to_quantized(cfg):
+            has_qlayer_outside_block = True
+
+    # 10. GGUF handling
+    if not gguf_name:
+        dispatch_layer_config(layer_config)
+        return layer_config, has_qlayer_outside_block
+
+    # embed + lm_head defaults for gguf
+    if lm_head_name not in layer_config and not tie_word_embeddings:
+        cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["lm_head"]]
+        cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
+        layer_config[lm_head_name] = cfg
+        has_qlayer_outside_block = True
+    for emd_name in embedding_layer_names:
+        cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
+        cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
+        layer_config[emd_name] = cfg
+
+    if enable_gguf_official_mixed:
+        model_type = ModelType.MMPROJ if is_mllm else ModelType.TEXT
+        layer_config, _ = get_layer_config_by_gguf_format(layer_config, gguf_name.lower(), model, model_type)
+
+    dispatch_layer_config(layer_config)
+    return layer_config, has_qlayer_outside_block
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 6376e92c2..b4f5e6041 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -5,15 +5,8 @@
 import unittest
 
 sys.path.insert(0, "../..")
-import torch
-import transformers
-from lm_eval.utils import make_table  # pylint: disable=E0401
-from transformers import AutoModelForCausalLM, AutoTokenizer
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
-from auto_round.eval.evaluation import simple_evaluate, simple_evaluate_user_model
-from auto_round.testing_utils import require_autogptq, require_greater_than_050, require_greater_than_051
-
 
 class TestAutoScheme(unittest.TestCase):
     @classmethod
@@ -28,6 +21,6 @@ def tearDownClass(self):
 
     def test_auto_scheme(self):
         model_name = "facebook/opt-125m"
-        scheme = AutoScheme(target_bits=3, options=("W2A16", "W4A16", "BF16"))
-        ar = AutoRound(model_name=model_name, scheme=scheme)
+        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1)
         ar.quantize_and_save(self.save_dir)

From 35a298b0f30c57df5e5af1808d3330538371c237 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 29 Sep 2025 08:37:38 +0000
Subject: [PATCH 29/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_scheme.py | 35 ++++++++++++++++++---------
 auto_round/compressors/base.py        | 32 +++++++++++++-----------
 auto_round/utils.py                   | 16 +++++++-----
 test/test_cuda/test_auto_scheme.py    |  1 +
 4 files changed, 53 insertions(+), 31 deletions(-)

diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
index badf39742..ba6b0a679 100644
--- a/auto_round/auto_schemes/gen_scheme.py
+++ b/auto_round/auto_schemes/gen_scheme.py
@@ -1,4 +1,18 @@
-from typing import Union, Iterable
+# 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 typing import Iterable, Union
 
 import torch
 
@@ -6,14 +20,13 @@
 
 
 class GenScheme:
-    def __init__(self,
-                 auto_scheme: AutoScheme,
-                 model: torch.nn.Module,
-                 quant_layer_names: Iterable[str],
-                 fixed_layer_scheme:dict[str, dict],
-                 scale_dtype: str = "fp16",
-                 dataset="pile-10k"
-                 ):
+    def __init__(
+        self,
+        auto_scheme: AutoScheme,
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        scale_dtype: str = "fp16",
+        dataset="pile-10k",
+    ):
         pass
-
-
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 495cf3d04..66c79274f 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -90,10 +90,11 @@
     mv_module_from_gpu,
     reset_params,
     set_amax_for_all_moe_layers,
+    set_layer_config,
     set_module,
     to_device,
     to_dtype,
-    unsupported_meta_device, set_layer_config,
+    unsupported_meta_device,
 )
 from auto_round.wrapper import WrapperLinear, WrapperMultiblock, unwrapper_block, unwrapper_layer, wrapper_block
 
@@ -292,23 +293,27 @@ def __init__(
             if self.mllm:
                 logger.info("AutoScheme with MLLM is not supported yet.")
                 sys.exit(1)
-            layer_config,_ = set_layer_config(self.model,
-            self.layer_config,
-            self.scheme,
-            self.scale_dtype,
-            self.supported_types,
-            self.inner_supported_types,
-            self.quant_block_list,
-            self.fp_layers,
-            self.quant_lm_head,
-            enable_gguf_official_mixed=False,
-            is_mllm=self.mllm)
+            layer_config, _ = set_layer_config(
+                self.model,
+                self.layer_config,
+                self.scheme,
+                self.scale_dtype,
+                self.supported_types,
+                self.inner_supported_types,
+                self.quant_block_list,
+                self.fp_layers,
+                self.quant_lm_head,
+                enable_gguf_official_mixed=False,
+                is_mllm=self.mllm,
+            )
             quant_layer_names = layer_config.keys()
             fixed_layer_scheme = {k: v for k, v in layer_config.items() if v.get("fixed_by_user", False)}
             # mainly using quant_layers and fixed by users
             from auto_round.auto_schemes.gen_scheme import GenScheme
-            gen_scheme = GenScheme(scheme,self.model,quant_layer_names,fixed_layer_scheme, self.scale_dtype, self.dataset)
 
+            gen_scheme = GenScheme(
+                scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, self.dataset
+            )
 
         # Set device, must place after model loading
         self._set_device(device_map)
@@ -421,7 +426,6 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         else:
             raise TypeError(f"device_map should be [str, torch.device, int, dict], but got {type(device_map)}")
 
-
     def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
         if isinstance(scheme, QuantizationScheme):
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 92e54a3ba..e865726b8 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -21,7 +21,7 @@
 import re
 import sys
 from collections import UserDict
-from dataclasses import fields, asdict
+from dataclasses import asdict, fields
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -2744,7 +2744,6 @@ def is_mllm_model(model_or_path: Union[str, torch.nn.Module]):
     return False
 
 
-
 def set_layer_config(
     model: torch.nn.Module,
     layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
@@ -2802,7 +2801,13 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
 
     # 1. fp_layers -> force 16
     for name in get_fp_layer_names(model, fp_layers):
-        layer_config[name] = {"bits": 16, "act_bits": 16, "data_type": "float", "act_data_type": "float","fixed_by_user":True}
+        layer_config[name] = {
+            "bits": 16,
+            "act_bits": 16,
+            "data_type": "float",
+            "act_data_type": "float",
+            "fixed_by_user": True,
+        }
 
     # 2. normalize
     layer_config = {k: normalize_item(v, k) for k, v in layer_config.items()}
@@ -2861,8 +2866,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     if quant_lm_head and tie_word_embeddings:
         quant_lm_head = False
         logger.warning(
-            "reset `quant_lm_head` to false as quantizing "
-            "lm_head with tied weights has not been supported currently"
+            "reset `quant_lm_head` to false as quantizing " "lm_head with tied weights has not been supported currently"
         )
 
     if lm_head_name not in layer_config and quant_lm_head:
@@ -2881,7 +2885,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     for name in get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types):
         if name not in layer_config:
             layer_config[name] = default_dict.copy()
-            layer_config[name]["fixed_by_user"]=False
+            layer_config[name]["fixed_by_user"] = False
         layer_config[name]["in_blocks"] = True
 
     # ---- restore: ensure missing in_blocks are set to False and compute flag ----
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index b4f5e6041..b9fffdee9 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -8,6 +8,7 @@
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 
+
 class TestAutoScheme(unittest.TestCase):
     @classmethod
     def setUpClass(self):

From 4a594cd5e778b2c5897e3131d72e21c7e46ba74f Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 29 Sep 2025 20:37:42 +0800
Subject: [PATCH 30/88] fix

---
 auto_round/compressors/base.py | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 66c79274f..955971306 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -725,20 +725,20 @@ def _check_compatibility(self) -> None:
                     " We are likely to release new algorithm for certain configurations in the future."
                 )
 
-        # Check group_size 32 for auto_round
-        if (
-            self.data_type == "int"
-            and hasattr(self, "formats")
-            and any(key in fmt for fmt in self.formats for key in ("auto_round", "auto_gptq", "auto_awq"))
-        ):
-            for n, m in self.model.named_modules():
-                if type(m) in self.supported_types:
-                    if m.weight.shape[0] % 32 != 0 or m.weight.shape[1] % 32 != 0:
-                        self.layer_config[n] = {"bits": 16}
-                        logger.info(
-                            f"{n} will not be quantized due to its shape not being divisible by 32,"
-                            " resulting in an exporting issue to autogptq"
-                        )
+        # # Check group_size 32 for auto_round
+        # if (
+        #     self.data_type == "int"
+        #     and hasattr(self, "formats")
+        #     and any(key in fmt for fmt in self.formats for key in ("auto_round", "auto_gptq", "auto_awq"))
+        # ):
+        #     for n, m in self.model.named_modules():
+        #         if type(m) in self.supported_types:
+        #             if m.weight.shape[0] % 32 != 0 or m.weight.shape[1] % 32 != 0:
+        #                 self.layer_config[n] = {"bits": 16}
+        #                 logger.info(
+        #                     f"{n} will not be quantized due to its shape not being divisible by 32,"
+        #                     " resulting in an exporting issue to autogptq"
+        #                 )
 
         if (
             self.seqlen is not None

From dcd08d629cc3840efdc24b8c9af97af2edf71095 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 30 Sep 2025 14:02:23 +0800
Subject: [PATCH 31/88] fix uts, still one left

---
 .../export/export_to_autoround/export_to_nvfp_mxfp.py    | 4 ++--
 auto_round/schemes.py                                    | 9 +++++++--
 auto_round/utils.py                                      | 5 +++++
 test/test_cpu/test_autoround.py                          | 1 +
 4 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py b/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
index c4a02f673..240a94899 100644
--- a/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
+++ b/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
@@ -174,7 +174,7 @@ def save_quantized_as_fp(output_dir, inplace=True, **kwargs):
         for n, m in model.named_modules():
             if type(m) in SUPPORTED_LAYER_TYPES:
                 layer = m
-                if layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
+                if hasattr(layer,"act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
                     assert hasattr(layer, "act_max")
                     from auto_round.data_type.nvfp import calculate_gparam
 
@@ -198,7 +198,7 @@ def save_quantized_as_fp(output_dir, inplace=True, **kwargs):
     for layer_name in layer_config:
         if (
             not layer_config[layer_name]["in_blocks"] and layer_config[layer_name]["bits"] <= 8
-        ):  ##lm head ##TODO fix act and so on
+        ):  ##lm head # TODO fix act and so on
             extra_config[layer_name] = {}
             extra_config[layer_name]["bits"] = layer_config[layer_name]["bits"]
             extra_config[layer_name]["data_type"] = layer_config[layer_name]["data_type"]
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index cf7d4d433..32be2fb52 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -238,11 +238,16 @@ def is_preset_scheme(name: str) -> bool:
 
 def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
     if isinstance(scheme, str) and scheme.upper().startswith("GGUF"):
-        return True
+        return scheme
     for key, val in PRESET_SCHEMES.items():
         if not key.upper().startswith("GGUF"):
             continue
-        if val == scheme:
+        equal = True
+        for scheme_key in val.keys():
+            if val[scheme_key] is not None and val[scheme_key] != scheme.get(scheme_key, None):
+                equal = False
+                break
+        if equal:
             return key
     return ""
 
diff --git a/auto_round/utils.py b/auto_round/utils.py
index e865726b8..009d516d8 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2834,7 +2834,9 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         supported_types = (*supported_types, torch.nn.Embedding)
 
     all_layer_names, embedding_layer_names = [], []
+    all_module_names = []
     for n, m in model.named_modules():
+        all_module_names.append(n)
         # cleanup stale attributes
         for key in scheme_keys:
             if hasattr(m, key):
@@ -2849,6 +2851,9 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     for name in list(layer_config.keys()):
         if name in all_layer_names:
             continue
+        if name in all_module_names:
+            logger.warning_once(f"the type of `{name}` is not supported in your scheme, ignore it for now.")
+            continue
         regex = re.compile(name)
         matched = [ln for ln in all_layer_names if regex.search(ln)]
         if not matched:
diff --git a/test/test_cpu/test_autoround.py b/test/test_cpu/test_autoround.py
index 9511f0cf8..aac524800 100644
--- a/test/test_cpu/test_autoround.py
+++ b/test/test_cpu/test_autoround.py
@@ -720,6 +720,7 @@ def test_invalid_layer_config(self):
                 iters=1,
                 layer_config=layer_config,
             )
+            ar.quantize()
 
     def test_quant_lm_head(self):
         model_name = "/tf_dataset/auto_round/models/Qwen/Qwen3-8B"

From 91722646068c4adcdbfefe058e3f486b58793a6f Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 30 Sep 2025 15:19:25 +0800
Subject: [PATCH 32/88] fix gguf issue

---
 auto_round/compressors/base.py |  6 ++++--
 auto_round/schemes.py          |  2 ++
 auto_round/utils.py            | 37 ++++++++++++++++++++++++++++++----
 3 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 955971306..0731d0ba8 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -428,11 +428,13 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
 
     def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
+        res= ""
         if isinstance(scheme, QuantizationScheme):
             scheme = asdict(scheme)
         elif isinstance(scheme, dict):
             scheme = scheme
         elif isinstance(scheme, str):
+            res = scheme # gguf:q4_k_s and gguf_q4_k_m has the same dict scheme, but the result is different
             scheme = scheme.upper()
             scheme = asdict(preset_name_to_scheme(scheme))
         scheme_keys = [f.name for f in fields(QuantizationScheme)]
@@ -481,7 +483,7 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
                     break
         for key in scheme_keys:
             scheme[key] = getattr(self, key)
-        return QuantizationScheme.from_dict(scheme)
+        return res if res else QuantizationScheme.from_dict(scheme)
 
     def _adjust_torch_compile(self, enable_torch_compile: bool) -> None:
         """Sets the torch compile configuration for the tuning."""
@@ -804,7 +806,7 @@ def remove_duplicates(lst):
 
         for f in formats:
             if f.startswith("gguf"):
-                self.scheme = preset_name_to_scheme(f)
+                self.scheme = f.upper()
                 break
 
         for format_ in formats:
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 32be2fb52..cde37a0c9 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -239,6 +239,8 @@ def is_preset_scheme(name: str) -> bool:
 def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
     if isinstance(scheme, str) and scheme.upper().startswith("GGUF"):
         return scheme
+    if isinstance(scheme, str):
+        return ""
     for key, val in PRESET_SCHEMES.items():
         if not key.upper().startswith("GGUF"):
             continue
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 009d516d8..84390fa43 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -35,7 +35,7 @@
 
 from auto_round.export.export_to_gguf.config import GGML_QUANT_SIZES, GGUF_CONFIG, GGUF_INNER_CONFIG, QK_K, ModelType
 from auto_round.logger import logger
-from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
+from auto_round.schemes import QuantizationScheme, preset_name_to_scheme, get_gguf_scheme
 
 SHARED_CACHE_KEYS = ("position_ids", "cache_position", "position_embeddings")
 
@@ -1940,6 +1940,30 @@ def _set_config(config, target_config):
                 )
                 new_type = new_type[:bits_index] + target_bits + new_type[bits_index + 1 :]
             else:
+                config_tmp = config.copy()
+                scheme_keys = [f.name for f in fields(QuantizationScheme)]
+                for key in config.keys():
+                    if key not in scheme_keys:
+                        config_tmp.pop(key, None)
+                matched_scheme = get_gguf_scheme(QuantizationScheme.from_dict(config_tmp)) # check matched
+                if not matched_scheme:
+                    if config.get("super_group_size", None) is not None:
+                        new_type = new_type[:bits_index] + str(config["bits"]) + "_k"
+                    if config.get("super_group_size", None) is None or new_type not in GGUF_INNER_CONFIG:
+                        if config.get("sym", True):
+                            new_type = new_type[:bits_index] + str(config["bits"]) + "_0"
+                            if new_type not in GGUF_INNER_CONFIG:
+                                new_type = new_type[:bits_index] + str(config["bits"]) + "_1"
+                        if not config.get("sym", True):
+                            new_type = new_type[:bits_index] + str(config["bits"]) + "_1"
+                            if new_type not in GGUF_INNER_CONFIG:
+                                new_type = new_type[:bits_index] + str(config["bits"]) + "_0"
+                    if new_type not in GGUF_INNER_CONFIG:
+                        raise ValueError(f"the setting in layer_config {layer_name} "
+                                         f"could not match any supported gguf format, please have a check.")
+                    else:
+                        logger.warning_once(f"the setting in layer_config {layer_name} "
+                                            f"could not match any supported gguf format, reset to {new_type}")
                 new_type = new_type[:bits_index] + str(config["bits"]) + new_type[bits_index + 1 :]
             new_type = _search_gguf_type(new_type)
             if new_type is None:
@@ -2747,7 +2771,7 @@ def is_mllm_model(model_or_path: Union[str, torch.nn.Module]):
 def set_layer_config(
     model: torch.nn.Module,
     layer_config: dict[str, Union[str, dict, "QuantizationScheme"]],
-    default_scheme: "QuantizationScheme",
+    default_scheme: Union[str, "QuantizationScheme"],
     default_scale_dtype: torch.dtype | str,
     supported_types: tuple,
     inner_supported_types: tuple,
@@ -2822,11 +2846,14 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
                 cfg["act_bits"] = b
 
     # 4. fill defaults
-    default_dict = asdict(default_scheme)
+    if isinstance(default_scheme,str):
+        default_dict = asdict(preset_name_to_scheme(default_scheme.upper()))
+    else:
+        default_dict = asdict(default_scheme)
     default_dict["scale_dtype"] = default_scale_dtype
     for cfg in layer_config.values():
         for key in scheme_keys:
-            cfg.setdefault(key, default_dict.get(key))
+            cfg.setdefault(key, default_dict.copy().get(key))
 
     # 5. collect supported modules
     gguf_name = get_gguf_scheme(default_scheme)
@@ -2914,6 +2941,8 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         layer_config[lm_head_name] = cfg
         has_qlayer_outside_block = True
     for emd_name in embedding_layer_names:
+        if emd_name in layer_config:
+            continue
         cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
         cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
         layer_config[emd_name] = cfg

From f98092c6e6b4e53e9d4653ec21fe4e7fa69a0ee3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 30 Sep 2025 07:25:15 +0000
Subject: [PATCH 33/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py                 |  5 ++---
 .../export_to_autoround/export_to_nvfp_mxfp.py |  2 +-
 auto_round/utils.py                            | 18 +++++++++++-------
 3 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index f957b2a5c..f1036ecac 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -328,7 +328,6 @@ def __init__(
             self.device_map = None
         self._set_device_map_in_blocks(self.device_map)
 
-
         # Tuning hyperparameters
         self.seed = seed
         set_seed(self.seed)
@@ -416,13 +415,13 @@ def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
 
     def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kwargs) -> QuantizationScheme:
         """Parse and set the quantization scheme."""
-        res= ""
+        res = ""
         if isinstance(scheme, QuantizationScheme):
             scheme = asdict(scheme)
         elif isinstance(scheme, dict):
             scheme = scheme
         elif isinstance(scheme, str):
-            res = scheme # gguf:q4_k_s and gguf_q4_k_m has the same dict scheme, but the result is different
+            res = scheme  # gguf:q4_k_s and gguf_q4_k_m has the same dict scheme, but the result is different
             scheme = scheme.upper()
             scheme = asdict(preset_name_to_scheme(scheme))
         scheme_keys = [f.name for f in fields(QuantizationScheme)]
diff --git a/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py b/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
index 240a94899..eaf3ad9ae 100644
--- a/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
+++ b/auto_round/export/export_to_autoround/export_to_nvfp_mxfp.py
@@ -174,7 +174,7 @@ def save_quantized_as_fp(output_dir, inplace=True, **kwargs):
         for n, m in model.named_modules():
             if type(m) in SUPPORTED_LAYER_TYPES:
                 layer = m
-                if hasattr(layer,"act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
+                if hasattr(layer, "act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
                     assert hasattr(layer, "act_max")
                     from auto_round.data_type.nvfp import calculate_gparam
 
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 187fc883d..a1c411373 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -35,7 +35,7 @@
 
 from auto_round.export.export_to_gguf.config import GGML_QUANT_SIZES, GGUF_CONFIG, GGUF_INNER_CONFIG, QK_K, ModelType
 from auto_round.logger import logger
-from auto_round.schemes import QuantizationScheme, preset_name_to_scheme, get_gguf_scheme
+from auto_round.schemes import QuantizationScheme, get_gguf_scheme, preset_name_to_scheme
 
 SHARED_CACHE_KEYS = ("position_ids", "cache_position", "position_embeddings")
 
@@ -1949,7 +1949,7 @@ def _set_config(config, target_config):
                 for key in config.keys():
                     if key not in scheme_keys:
                         config_tmp.pop(key, None)
-                matched_scheme = get_gguf_scheme(QuantizationScheme.from_dict(config_tmp)) # check matched
+                matched_scheme = get_gguf_scheme(QuantizationScheme.from_dict(config_tmp))  # check matched
                 if not matched_scheme:
                     if config.get("super_group_size", None) is not None:
                         new_type = new_type[:bits_index] + str(config["bits"]) + "_k"
@@ -1963,11 +1963,15 @@ def _set_config(config, target_config):
                             if new_type not in GGUF_INNER_CONFIG:
                                 new_type = new_type[:bits_index] + str(config["bits"]) + "_0"
                     if new_type not in GGUF_INNER_CONFIG:
-                        raise ValueError(f"the setting in layer_config {layer_name} "
-                                         f"could not match any supported gguf format, please have a check.")
+                        raise ValueError(
+                            f"the setting in layer_config {layer_name} "
+                            f"could not match any supported gguf format, please have a check."
+                        )
                     else:
-                        logger.warning_once(f"the setting in layer_config {layer_name} "
-                                            f"could not match any supported gguf format, reset to {new_type}")
+                        logger.warning_once(
+                            f"the setting in layer_config {layer_name} "
+                            f"could not match any supported gguf format, reset to {new_type}"
+                        )
                 new_type = new_type[:bits_index] + str(config["bits"]) + new_type[bits_index + 1 :]
             new_type = _search_gguf_type(new_type)
             if new_type is None:
@@ -2850,7 +2854,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
                 cfg["act_bits"] = b
 
     # 4. fill defaults
-    if isinstance(default_scheme,str):
+    if isinstance(default_scheme, str):
         default_dict = asdict(preset_name_to_scheme(default_scheme.upper()))
     else:
         default_dict = asdict(default_scheme)

From 033d1f6ed3e4b4a128a07c964af01b156c820704 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 30 Sep 2025 16:48:32 +0800
Subject: [PATCH 34/88] update a little

---
 auto_round/auto_schemes/gen_scheme.py | 66 ++++++++++++++++++++++++---
 1 file changed, 59 insertions(+), 7 deletions(-)

diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
index ba6b0a679..03c253a6a 100644
--- a/auto_round/auto_schemes/gen_scheme.py
+++ b/auto_round/auto_schemes/gen_scheme.py
@@ -17,16 +17,68 @@
 import torch
 
 from auto_round import AutoScheme
+from auto_round.utils import get_layer_features
 
 
 class GenScheme:
     def __init__(
-        self,
-        auto_scheme: AutoScheme,
-        model: torch.nn.Module,
-        quant_layer_names: Iterable[str],
-        fixed_layer_scheme: dict[str, dict],
-        scale_dtype: str = "fp16",
-        dataset="pile-10k",
+            self,
+            auto_scheme: AutoScheme,
+            model: torch.nn.Module,
+            quant_layer_names: Iterable[str],
+            fixed_layer_scheme: dict[str, dict],
+            scale_dtype: str = "fp16",
+            dataset="pile-10k",
     ):
+        self.auto_scheme = auto_scheme
+        self.model = model
+        self.quant_layer_names = quant_layer_names
+        self.fixed_layer_scheme = fixed_layer_scheme
+        self.scale_dtype = scale_dtype
+        self.dataset = dataset
+
+    def _get_min_max_avg_bits(self) -> tuple[float, float]:
         pass
+
+    # not validate yet
+    def get_layer_bits(self, layer):
+        weight = layer.weight
+        n_param = weight.numel()
+        weight_bits = getattr(layer, 'bits', 16)
+        group_size = getattr(layer, 'group_size', 128)
+        super_group_size = getattr(layer, 'super_group_size', None)
+        super_weight_bits = getattr(layer, 'super_bits', None)
+
+        # Main quantization cost
+        weight_total_bits = weight_bits * n_param
+        if weight_bits>=16: # Unquantized layer
+            return weight_total_bits, 16
+
+        in_features, output_features = get_layer_features(layer)
+        # Determine number of groups
+        if group_size > 0:  # group-wise
+            n_group = output_features * (in_features + group_size - 1) // group_size
+        elif group_size == 0:  # per-tensor
+            n_group = 1
+        elif group_size == -1:  # per-channel
+            n_group = output_features  # out_channels
+        else:
+            raise ValueError(f"Invalid group_size {group_size}")
+        aux_total_bits = 0
+        if not super_group_size:
+            # Scale and zero point bitwidths
+            scale_bits = 16
+            zp_bits = weight_bits if not super_group_size else 32  # default: same as weight_bits
+            # Overhead from scales and zero points
+            aux_total_bits = n_group * (scale_bits + zp_bits)
+
+        # Double quantization case
+        if super_group_size:
+            # Number of super-groups
+            aux_total_bits+=n_group*super_weight_bits * 2 #sclae and min int count
+            n_super_group = (n_group + super_group_size - 1) // super_group_size
+            aux_total_bits += n_super_group * 32 * 2 # double quant scale and min_v
+
+        total_bits = weight_total_bits + aux_total_bits
+        avg_bits = total_bits / n_param
+        return total_bits, avg_bits

From 8ae1dfa56220727b39c2c29eacb22a98ab998e10 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 30 Sep 2025 08:50:03 +0000
Subject: [PATCH 35/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_scheme.py | 28 +++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
index 03c253a6a..e009e12de 100644
--- a/auto_round/auto_schemes/gen_scheme.py
+++ b/auto_round/auto_schemes/gen_scheme.py
@@ -22,13 +22,13 @@
 
 class GenScheme:
     def __init__(
-            self,
-            auto_scheme: AutoScheme,
-            model: torch.nn.Module,
-            quant_layer_names: Iterable[str],
-            fixed_layer_scheme: dict[str, dict],
-            scale_dtype: str = "fp16",
-            dataset="pile-10k",
+        self,
+        auto_scheme: AutoScheme,
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        scale_dtype: str = "fp16",
+        dataset="pile-10k",
     ):
         self.auto_scheme = auto_scheme
         self.model = model
@@ -44,14 +44,14 @@ def _get_min_max_avg_bits(self) -> tuple[float, float]:
     def get_layer_bits(self, layer):
         weight = layer.weight
         n_param = weight.numel()
-        weight_bits = getattr(layer, 'bits', 16)
-        group_size = getattr(layer, 'group_size', 128)
-        super_group_size = getattr(layer, 'super_group_size', None)
-        super_weight_bits = getattr(layer, 'super_bits', None)
+        weight_bits = getattr(layer, "bits", 16)
+        group_size = getattr(layer, "group_size", 128)
+        super_group_size = getattr(layer, "super_group_size", None)
+        super_weight_bits = getattr(layer, "super_bits", None)
 
         # Main quantization cost
         weight_total_bits = weight_bits * n_param
-        if weight_bits>=16: # Unquantized layer
+        if weight_bits >= 16:  # Unquantized layer
             return weight_total_bits, 16
 
         in_features, output_features = get_layer_features(layer)
@@ -75,9 +75,9 @@ def get_layer_bits(self, layer):
         # Double quantization case
         if super_group_size:
             # Number of super-groups
-            aux_total_bits+=n_group*super_weight_bits * 2 #sclae and min int count
+            aux_total_bits += n_group * super_weight_bits * 2  # sclae and min int count
             n_super_group = (n_group + super_group_size - 1) // super_group_size
-            aux_total_bits += n_super_group * 32 * 2 # double quant scale and min_v
+            aux_total_bits += n_super_group * 32 * 2  # double quant scale and min_v
 
         total_bits = weight_total_bits + aux_total_bits
         avg_bits = total_bits / n_param

From a3756ce3ac84771c5bbb1b3abc62d61f29526312 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 9 Oct 2025 11:57:44 +0800
Subject: [PATCH 36/88] fix some issues

---
 auto_round/auto_schemes/gen_scheme.py                     | 2 +-
 auto_round/export/export_to_autoround/export_to_fp8.py    | 8 +++++---
 auto_round/export/export_to_llmcompressor/export_to_fp.py | 2 +-
 auto_round/utils.py                                       | 4 ++--
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
index e009e12de..da4a6345b 100644
--- a/auto_round/auto_schemes/gen_scheme.py
+++ b/auto_round/auto_schemes/gen_scheme.py
@@ -75,7 +75,7 @@ def get_layer_bits(self, layer):
         # Double quantization case
         if super_group_size:
             # Number of super-groups
-            aux_total_bits += n_group * super_weight_bits * 2  # sclae and min int count
+            aux_total_bits += n_group * super_weight_bits * 2  # scale and min int count
             n_super_group = (n_group + super_group_size - 1) // super_group_size
             aux_total_bits += n_super_group * 32 * 2  # double quant scale and min_v
 
diff --git a/auto_round/export/export_to_autoround/export_to_fp8.py b/auto_round/export/export_to_autoround/export_to_fp8.py
index 7f069cb60..a68d5b207 100644
--- a/auto_round/export/export_to_autoround/export_to_fp8.py
+++ b/auto_round/export/export_to_autoround/export_to_fp8.py
@@ -109,10 +109,12 @@ def pack_layer(layer_name, model, data_type, device=None):
         torch_dtype = torch.float8_e5m2
     info = torch.finfo(torch_dtype)
     if zp is not None:
+        if not isinstance(zp, torch.Tensor):
+            zp = torch.tensor(zp, dtype=weight.dtype)
+
+        zp =  zp.to(packing_device)
         q_weight = (
-            weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1) + zp.to(packing_device)
-            if isinstance(zp, torch.Tensor)
-            else zp
+            weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1) + zp
         )
     else:
         q_weight = weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1)
diff --git a/auto_round/export/export_to_llmcompressor/export_to_fp.py b/auto_round/export/export_to_llmcompressor/export_to_fp.py
index 1a56ebf12..6fcce8472 100644
--- a/auto_round/export/export_to_llmcompressor/export_to_fp.py
+++ b/auto_round/export/export_to_llmcompressor/export_to_fp.py
@@ -169,7 +169,7 @@ def save_quantized_as_fp(output_dir, inplace=True, **kwargs):
         for n, m in model.named_modules():
             if type(m) in SUPPORTED_LAYER_TYPES:
                 layer = m
-                if layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
+                if hasattr(layer,"act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
                     assert hasattr(layer, "act_max")
                     from auto_round.data_type.nvfp import calculate_gparam
 
diff --git a/auto_round/utils.py b/auto_round/utils.py
index a1c411373..8e050c5df 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2223,9 +2223,9 @@ def get_reciprocal(tensor):
 
 
 def check_need_act_calibration(
-    is_act_dynamic: Union[bool, None], act_data_type: Union[str, None] = None, act_bits: int = 16
+    is_act_dynamic: Union[bool, None], act_data_type: Union[str, None] = None, act_bits: Union[int,None] = 16
 ) -> bool:
-    if act_bits > 8:
+    if act_bits is None or act_bits > 8:
         return False
     # None is dynamic
     if is_act_dynamic is not None and not is_act_dynamic:

From 2f93471694d13decdbf29713155fc9d334d63da1 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 9 Oct 2025 14:09:28 +0800
Subject: [PATCH 37/88] fix some issues

---
 auto_round/compressors/base.py |  9 ++++++---
 auto_round/schemes.py          |  8 ++++++++
 auto_round/utils.py            | 11 ++++-------
 3 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index f1036ecac..a687aecf5 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -463,14 +463,17 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
                 f" match the specified 'act_bits' setting. Resetting 'act_bits' to {tmp_act_bits}."
             )
         if tmp_act_bits is not None and tmp_act_bits < 16:
-            for supported_dtype in SUPPORTED_DTYPES:  # to easily handle dtype mx_fp4 and layer_config={xxx:{bits:8}}
+            for supported_dtype in SUPPORTED_DTYPES:  # To easily handle dtype mx_fp4 and layer_config={xxx:{bits:8}}
                 if self.act_data_type.startswith(supported_dtype):
-                    if supported_dtype + str(tmp_act_bits) == self.act_data_type:  # could not replace FP8_e4m3
+                    if supported_dtype + str(tmp_act_bits) == self.act_data_type:  # Could not replace FP8_e4m3
                         self.act_data_type = supported_dtype
                     break
         for key in scheme_keys:
             scheme[key] = getattr(self, key)
-        return res if res else QuantizationScheme.from_dict(scheme)
+        if res and QuantizationScheme.from_dict(scheme) == preset_name_to_scheme(res):
+            return res
+        else:
+            return  QuantizationScheme.from_dict(scheme)
 
     def _adjust_torch_compile(self, enable_torch_compile: bool) -> None:
         """Sets the torch compile configuration for the tuning."""
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index cde37a0c9..bc84589fd 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -72,7 +72,15 @@ def get(self, key: str, default=None):
     def __eq__(self, other: "QuantizationScheme") -> bool:
         if not isinstance(other, QuantizationScheme):
             return False
+        skip_act_check= False
+        self_act_bits = 16  if self.act_bits is None else self.act_bits
+        other_act_bits =  16  if other.act_bits is None else other.act_bits
+        if self_act_bits==other_act_bits and other_act_bits>=16:
+            skip_act_check = True
+
         for field in self.get_attributes():
+            if skip_act_check and field.startswith("act_"):
+                continue
             if getattr(self, field) != getattr(other, field):
                 return False
         return True
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 8e050c5df..de61d6d2c 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2868,7 +2868,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     if gguf_name and torch.nn.Embedding not in supported_types:
         supported_types = (*supported_types, torch.nn.Embedding)
 
-    all_layer_names, embedding_layer_names = [], []
+    all_supported_layer_names, embedding_layer_names = [], []
     all_module_names = []
     for n, m in model.named_modules():
         all_module_names.append(n)
@@ -2878,19 +2878,16 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
                 delattr(m, key)
         if type(m) not in supported_types and m.__class__.__name__ not in inner_supported_types:
             continue
-        all_layer_names.append(n)
+        all_supported_layer_names.append(n)
         if isinstance(m, torch.nn.Embedding):
             embedding_layer_names.append(n)
 
     # 6. expand regex configs
     for name in list(layer_config.keys()):
-        if name in all_layer_names:
-            continue
-        if name in all_module_names:
-            logger.warning_once(f"the type of `{name}` is not supported in your scheme, ignore it for now.")
+        if name in all_supported_layer_names:
             continue
         regex = re.compile(name)
-        matched = [ln for ln in all_layer_names if regex.search(ln)]
+        matched = [ln for ln in all_supported_layer_names if regex.search(ln)]
         if not matched:
             raise ValueError(f"Invalid '{name}' in layer_config, no match found.")
         val = layer_config.pop(name)

From e0c3d4bb2fb49b2eb04333914604b054583b0419 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 9 Oct 2025 06:10:15 +0000
Subject: [PATCH 38/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py                            | 2 +-
 auto_round/export/export_to_autoround/export_to_fp8.py    | 6 ++----
 auto_round/export/export_to_llmcompressor/export_to_fp.py | 2 +-
 auto_round/schemes.py                                     | 8 ++++----
 auto_round/utils.py                                       | 2 +-
 5 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index a687aecf5..ffee2ae3e 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -473,7 +473,7 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
         if res and QuantizationScheme.from_dict(scheme) == preset_name_to_scheme(res):
             return res
         else:
-            return  QuantizationScheme.from_dict(scheme)
+            return QuantizationScheme.from_dict(scheme)
 
     def _adjust_torch_compile(self, enable_torch_compile: bool) -> None:
         """Sets the torch compile configuration for the tuning."""
diff --git a/auto_round/export/export_to_autoround/export_to_fp8.py b/auto_round/export/export_to_autoround/export_to_fp8.py
index a68d5b207..455768e37 100644
--- a/auto_round/export/export_to_autoround/export_to_fp8.py
+++ b/auto_round/export/export_to_autoround/export_to_fp8.py
@@ -112,10 +112,8 @@ def pack_layer(layer_name, model, data_type, device=None):
         if not isinstance(zp, torch.Tensor):
             zp = torch.tensor(zp, dtype=weight.dtype)
 
-        zp =  zp.to(packing_device)
-        q_weight = (
-            weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1) + zp
-        )
+        zp = zp.to(packing_device)
+        q_weight = weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1) + zp
     else:
         q_weight = weight.to(packing_device) / scale.to(packing_device).unsqueeze(-1)
     q_weight = revert_tensor_by_pad(q_weight, orig_shape=orig_shape, pad_len=pad_len)
diff --git a/auto_round/export/export_to_llmcompressor/export_to_fp.py b/auto_round/export/export_to_llmcompressor/export_to_fp.py
index 6fcce8472..633593075 100644
--- a/auto_round/export/export_to_llmcompressor/export_to_fp.py
+++ b/auto_round/export/export_to_llmcompressor/export_to_fp.py
@@ -169,7 +169,7 @@ def save_quantized_as_fp(output_dir, inplace=True, **kwargs):
         for n, m in model.named_modules():
             if type(m) in SUPPORTED_LAYER_TYPES:
                 layer = m
-                if hasattr(layer,"act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
+                if hasattr(layer, "act_bits") and layer.act_bits < 8 and not getattr(layer, "input_global_scale", None):
                     assert hasattr(layer, "act_max")
                     from auto_round.data_type.nvfp import calculate_gparam
 
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index bc84589fd..ac5393e2c 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -72,10 +72,10 @@ def get(self, key: str, default=None):
     def __eq__(self, other: "QuantizationScheme") -> bool:
         if not isinstance(other, QuantizationScheme):
             return False
-        skip_act_check= False
-        self_act_bits = 16  if self.act_bits is None else self.act_bits
-        other_act_bits =  16  if other.act_bits is None else other.act_bits
-        if self_act_bits==other_act_bits and other_act_bits>=16:
+        skip_act_check = False
+        self_act_bits = 16 if self.act_bits is None else self.act_bits
+        other_act_bits = 16 if other.act_bits is None else other.act_bits
+        if self_act_bits == other_act_bits and other_act_bits >= 16:
             skip_act_check = True
 
         for field in self.get_attributes():
diff --git a/auto_round/utils.py b/auto_round/utils.py
index de61d6d2c..0e5637b66 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2223,7 +2223,7 @@ def get_reciprocal(tensor):
 
 
 def check_need_act_calibration(
-    is_act_dynamic: Union[bool, None], act_data_type: Union[str, None] = None, act_bits: Union[int,None] = 16
+    is_act_dynamic: Union[bool, None], act_data_type: Union[str, None] = None, act_bits: Union[int, None] = 16
 ) -> bool:
     if act_bits is None or act_bits > 8:
         return False

From 6e04d100336e80ba775c43b098bc7d54b4836161 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 9 Oct 2025 16:07:45 +0800
Subject: [PATCH 39/88] update

---
 auto_round/auto_schemes/__init__.py        |   2 +-
 auto_round/auto_schemes/gen_auto_scheme.py |  71 ++++++++++
 auto_round/auto_schemes/gen_scheme.py      |  84 -----------
 auto_round/auto_schemes/utils.py           | 153 ++++++++++++++++++++-
 auto_round/compressors/base.py             |   4 +-
 auto_round/schemes.py                      |   1 +
 auto_round/utils.py                        |   7 +
 7 files changed, 231 insertions(+), 91 deletions(-)
 create mode 100644 auto_round/auto_schemes/gen_auto_scheme.py
 delete mode 100644 auto_round/auto_schemes/gen_scheme.py

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index d3b055be2..285c68666 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -15,7 +15,7 @@
 AUTO_SCHEMES_ALGS = {}
 
 
-def register_dtype(names):
+def register_scheme_algs(names):
     """Class decorator to register a mixed precision algorithm to the registry.
 
     Decorator function used before a Pattern subclass.
diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
new file mode 100644
index 000000000..a9510e10e
--- /dev/null
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -0,0 +1,71 @@
+# 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 dataclasses import asdict
+from typing import Iterable
+import torch
+from auto_round import AutoScheme
+from auto_round.logger import logger
+from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
+
+
+class GenScheme:
+    """Generate and validate quantization schemes for model layers."""
+
+    def __init__(
+        self,
+        auto_scheme: AutoScheme,
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        scale_dtype: str = "fp16",
+        dataset: str = "pile-10k",
+    ):
+        self.auto_scheme = auto_scheme
+        self.model = model
+        self.quant_layer_names = quant_layer_names
+        self.fixed_layer_scheme = fixed_layer_scheme
+        self.scale_dtype = scale_dtype
+        self.dataset = dataset
+
+        self._check_configs()
+
+    def _check_configs(self) -> None:
+        """Validate auto_scheme configuration and ensure avg_bits target is valid."""
+        if not isinstance(self.dataset, str):
+            raise TypeError("`dataset` must be a string, got {type(self.dataset).__name__}.")
+
+        min_avg_bit, max_avg_bit = self.compute_avg_bit_range()
+        target = self.auto_scheme.avg_bits
+
+        logger.info("Average bits range: [%.2f, %.2f], target = %.2f", min_avg_bit, max_avg_bit, target)
+
+        if not (min_avg_bit <= target <= max_avg_bit):
+            raise ValueError(
+                f"Target avg_bits={target:.2f} is outside the valid range "
+                f"[{min_avg_bit:.2f}, {max_avg_bit:.2f}]."
+            )
+
+    def compute_avg_bit_range(self) -> tuple[float, float]:
+        """Compute the min and max average bitwidths among candidate quantization options."""
+        avg_bits = [
+            compute_avg_bits_for_scheme(
+                self.model,
+                self.quant_layer_names,
+                self.fixed_layer_scheme,
+                option,
+                self.auto_scheme.ignore_scale_zp_bits,
+            )[0]
+            for option in self.auto_scheme.options
+        ]
+        return min(avg_bits), max(avg_bits)
\ No newline at end of file
diff --git a/auto_round/auto_schemes/gen_scheme.py b/auto_round/auto_schemes/gen_scheme.py
deleted file mode 100644
index da4a6345b..000000000
--- a/auto_round/auto_schemes/gen_scheme.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# 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 typing import Iterable, Union
-
-import torch
-
-from auto_round import AutoScheme
-from auto_round.utils import get_layer_features
-
-
-class GenScheme:
-    def __init__(
-        self,
-        auto_scheme: AutoScheme,
-        model: torch.nn.Module,
-        quant_layer_names: Iterable[str],
-        fixed_layer_scheme: dict[str, dict],
-        scale_dtype: str = "fp16",
-        dataset="pile-10k",
-    ):
-        self.auto_scheme = auto_scheme
-        self.model = model
-        self.quant_layer_names = quant_layer_names
-        self.fixed_layer_scheme = fixed_layer_scheme
-        self.scale_dtype = scale_dtype
-        self.dataset = dataset
-
-    def _get_min_max_avg_bits(self) -> tuple[float, float]:
-        pass
-
-    # not validate yet
-    def get_layer_bits(self, layer):
-        weight = layer.weight
-        n_param = weight.numel()
-        weight_bits = getattr(layer, "bits", 16)
-        group_size = getattr(layer, "group_size", 128)
-        super_group_size = getattr(layer, "super_group_size", None)
-        super_weight_bits = getattr(layer, "super_bits", None)
-
-        # Main quantization cost
-        weight_total_bits = weight_bits * n_param
-        if weight_bits >= 16:  # Unquantized layer
-            return weight_total_bits, 16
-
-        in_features, output_features = get_layer_features(layer)
-        # Determine number of groups
-        if group_size > 0:  # group-wise
-            n_group = output_features * (in_features + group_size - 1) // group_size
-        elif group_size == 0:  # per-tensor
-            n_group = 1
-        elif group_size == -1:  # per-channel
-            n_group = output_features  # out_channels
-        else:
-            raise ValueError(f"Invalid group_size {group_size}")
-        aux_total_bits = 0
-        if not super_group_size:
-            # Scale and zero point bitwidths
-            scale_bits = 16
-            zp_bits = weight_bits if not super_group_size else 32  # default: same as weight_bits
-            # Overhead from scales and zero points
-            aux_total_bits = n_group * (scale_bits + zp_bits)
-
-        # Double quantization case
-        if super_group_size:
-            # Number of super-groups
-            aux_total_bits += n_group * super_weight_bits * 2  # scale and min int count
-            n_super_group = (n_group + super_group_size - 1) // super_group_size
-            aux_total_bits += n_super_group * 32 * 2  # double quant scale and min_v
-
-        total_bits = weight_total_bits + aux_total_bits
-        avg_bits = total_bits / n_param
-        return total_bits, avg_bits
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index e01da9913..74fbc2029 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -11,11 +11,156 @@
 # 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 dataclasses import asdict
+from typing import Union, Iterable
 
+import torch
+from auto_round.low_cpu_mem import get_module
+from auto_round.schemes import preset_name_to_scheme
+from auto_round.utils import get_layer_features
 
-def get_total_bits(model, layer_config):
-    pass
 
+def apply_quant_scheme(
+    model: torch.nn.Module,
+    quant_layer_names: Iterable[str],
+    fixed_layer_scheme: dict[str, dict],
+    scheme: Union[str, dict],
+) -> None:
+    """Apply a quantization scheme to each quantized layer.
 
-def get_bits(layer):
-    pass
+    Args:
+        model: The model whose layers are to be updated.
+        scheme: The scheme preset name or dictionary to apply.
+        quant_layer_names: Iterable of layer names to quantize.
+        fixed_layer_scheme: Dictionary of fixed per-layer quantization schemes.
+    """
+    for name in quant_layer_names:
+        layer_scheme = fixed_layer_scheme.get(name, scheme)
+        if isinstance(layer_scheme, str):
+            layer_scheme = asdict(preset_name_to_scheme(layer_scheme))
+
+        module = get_module(model, name)
+        for key, value in layer_scheme.items():
+            setattr(module, key, value)
+
+
+def remove_quant_scheme(
+    model: torch.nn.Module,
+    quant_layer_names: Iterable[str],
+    fixed_layer_scheme: dict[str, dict],
+    scheme: Union[str, dict],
+) -> None:
+    """Remove attributes corresponding to the applied quantization scheme.
+
+    Args:
+        model: The model whose layers are to be cleared.
+        scheme: The scheme preset name or dictionary previously applied.
+        quant_layer_names: Iterable of layer names to clear.
+        fixed_layer_scheme: Dictionary of fixed per-layer quantization schemes.
+    """
+    for name in quant_layer_names:
+        layer_scheme = fixed_layer_scheme.get(name, scheme)
+        if isinstance(layer_scheme, str):
+            layer_scheme = asdict(preset_name_to_scheme(layer_scheme))
+
+        module = get_module(model, name)
+        for key in layer_scheme.keys():
+            if hasattr(module, key):
+                delattr(module, key)
+
+
+def compute_avg_bits_for_scheme(
+    model: torch.nn.Module,
+    quant_layer_names: Iterable[str],
+    fixed_layer_scheme: dict[str, dict],
+    scheme: Union[str, dict, None] = None,
+    ignore_scale_zp_bits: bool = False,
+) -> tuple[float, float]:
+    """Compute the average and total bit usage for the given quantization scheme.
+
+    Args:
+        model: The model to analyze.
+        quant_layer_names: Iterable of layer names to include.
+        fixed_layer_scheme: Dictionary of fixed per-layer quantization schemes.
+        scheme: Optional scheme to temporarily apply before measuring.
+        ignore_scale_zp_bits: If True, ignores overhead from scale and zero-points.
+
+    Returns:
+        A tuple (avg_bits, total_quantized_bits):
+            avg_bits: Average bitwidth per parameter.
+            total_quantized_bits: Total quantized bit count.
+    """
+    if scheme is not None:
+        apply_quant_scheme(model, quant_layer_names, fixed_layer_scheme,scheme)
+
+    total_params = 0
+    total_quantized_bits = 0
+
+    for name in quant_layer_names:
+        module = get_module(model, name)
+        if not hasattr(module, "weight"):
+            continue
+        total_params += module.weight.numel()
+        layer_bits, _ = compute_layer_bits(module, ignore_scale_zp_bits)
+        total_quantized_bits += layer_bits
+
+    avg_bits = float(total_quantized_bits) / total_params
+
+    if scheme is not None:
+        remove_quant_scheme(model, quant_layer_names, fixed_layer_scheme, scheme)
+
+    return avg_bits, total_quantized_bits
+
+
+def compute_layer_bits(
+    layer: torch.nn.Module,
+    ignore_scale_zp_bits: bool = False,
+) -> tuple[int, float]:
+    """Compute total and average bitwidth for a single quantized layer.
+
+    Args:
+        layer: A PyTorch layer with quantization attributes.
+        ignore_scale_zp_bits: Whether to ignore scale/zero-point overhead.
+
+    Returns:
+        A tuple (total_bits, avg_bits) representing bit usage.
+    """
+    weight = layer.weight
+    n_param = weight.numel()
+    weight_bits = getattr(layer, "bits", 16)
+    group_size = getattr(layer, "group_size", 128)
+    super_group_size = getattr(layer, "super_group_size", None)
+    super_weight_bits = getattr(layer, "super_bits", None)
+
+    # Unquantized layer or ignoring scale/zp overhead
+    if weight_bits >= 16 or ignore_scale_zp_bits:
+        if super_weight_bits is not None: # reset gguf 16 bits to 32 bits
+            return 32 * n_param, 32
+        return weight_bits * n_param, 16.0
+
+    in_features, out_features = get_layer_features(layer)
+
+    # Determine number of groups based on group size
+    if group_size > 0:
+        n_group = out_features * (in_features + group_size - 1) // group_size
+    elif group_size == 0:
+        n_group = 1
+    elif group_size == -1:
+        n_group = out_features
+    else:
+        raise ValueError(f"Invalid group_size {group_size}")
+
+    # Compute auxiliary bits (scales, zero-points, or double quantization)
+    aux_total_bits = 0
+    if not super_group_size:
+        scale_bits = 16
+        zp_bits = weight_bits
+        aux_total_bits = n_group * (scale_bits + zp_bits)
+    else:
+        aux_total_bits += n_group * super_weight_bits * 2
+        n_super_group = (n_group + super_group_size - 1) // super_group_size
+        aux_total_bits += n_super_group * 32 * 2  # 32-bit scale and min_v
+
+    total_bits = weight_bits * n_param + aux_total_bits
+    avg_bits = total_bits / n_param
+    return total_bits, avg_bits
\ No newline at end of file
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index fdb7b6213..a71e15059 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -309,10 +309,10 @@ def __init__(
             quant_layer_names = layer_config.keys()
             fixed_layer_scheme = {k: v for k, v in layer_config.items() if v.get("fixed_by_user", False)}
             # mainly using quant_layers and fixed by users
-            from auto_round.auto_schemes.gen_scheme import GenScheme
+            from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
             gen_scheme = GenScheme(
-                scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, self.dataset
+                scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, dataset
             )
 
         # Set device, must place after model loading
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index ac5393e2c..2c087285e 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -268,3 +268,4 @@ class AutoScheme:
     avg_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
+    ignore_scale_zp_bits = False
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 0e5637b66..319f73b45 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2886,6 +2886,13 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     for name in list(layer_config.keys()):
         if name in all_supported_layer_names:
             continue
+        if name in all_module_names :
+            m = get_module(model, name)
+            if len(list(m.children())) == 0 and type(m) not in supported_types:
+                logger.warning(f"{name} is not supported in current scheme, ignoring its setting in `layer_config`")
+                continue
+
+
         regex = re.compile(name)
         matched = [ln for ln in all_supported_layer_names if regex.search(ln)]
         if not matched:

From 04c604cd3eccfdaf62878b4daf7a2a5838eecc8c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 9 Oct 2025 08:08:29 +0000
Subject: [PATCH 40/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_auto_scheme.py | 9 +++++----
 auto_round/auto_schemes/utils.py           | 9 +++++----
 auto_round/compressors/base.py             | 4 +---
 auto_round/utils.py                        | 3 +--
 4 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index a9510e10e..f4b668f17 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -13,10 +13,12 @@
 # limitations under the License.
 from dataclasses import asdict
 from typing import Iterable
+
 import torch
+
 from auto_round import AutoScheme
-from auto_round.logger import logger
 from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
+from auto_round.logger import logger
 
 
 class GenScheme:
@@ -52,8 +54,7 @@ def _check_configs(self) -> None:
 
         if not (min_avg_bit <= target <= max_avg_bit):
             raise ValueError(
-                f"Target avg_bits={target:.2f} is outside the valid range "
-                f"[{min_avg_bit:.2f}, {max_avg_bit:.2f}]."
+                f"Target avg_bits={target:.2f} is outside the valid range " f"[{min_avg_bit:.2f}, {max_avg_bit:.2f}]."
             )
 
     def compute_avg_bit_range(self) -> tuple[float, float]:
@@ -68,4 +69,4 @@ def compute_avg_bit_range(self) -> tuple[float, float]:
             )[0]
             for option in self.auto_scheme.options
         ]
-        return min(avg_bits), max(avg_bits)
\ No newline at end of file
+        return min(avg_bits), max(avg_bits)
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 74fbc2029..3122f1600 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from dataclasses import asdict
-from typing import Union, Iterable
+from typing import Iterable, Union
 
 import torch
+
 from auto_round.low_cpu_mem import get_module
 from auto_round.schemes import preset_name_to_scheme
 from auto_round.utils import get_layer_features
@@ -91,7 +92,7 @@ def compute_avg_bits_for_scheme(
             total_quantized_bits: Total quantized bit count.
     """
     if scheme is not None:
-        apply_quant_scheme(model, quant_layer_names, fixed_layer_scheme,scheme)
+        apply_quant_scheme(model, quant_layer_names, fixed_layer_scheme, scheme)
 
     total_params = 0
     total_quantized_bits = 0
@@ -134,7 +135,7 @@ def compute_layer_bits(
 
     # Unquantized layer or ignoring scale/zp overhead
     if weight_bits >= 16 or ignore_scale_zp_bits:
-        if super_weight_bits is not None: # reset gguf 16 bits to 32 bits
+        if super_weight_bits is not None:  # reset gguf 16 bits to 32 bits
             return 32 * n_param, 32
         return weight_bits * n_param, 16.0
 
@@ -163,4 +164,4 @@ def compute_layer_bits(
 
     total_bits = weight_bits * n_param + aux_total_bits
     avg_bits = total_bits / n_param
-    return total_bits, avg_bits
\ No newline at end of file
+    return total_bits, avg_bits
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index a71e15059..c72eeecb5 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -311,9 +311,7 @@ def __init__(
             # mainly using quant_layers and fixed by users
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
-            gen_scheme = GenScheme(
-                scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, dataset
-            )
+            gen_scheme = GenScheme(scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, dataset)
 
         # Set device, must place after model loading
         self._set_device(device_map)
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 319f73b45..1e4a5c131 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2886,13 +2886,12 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     for name in list(layer_config.keys()):
         if name in all_supported_layer_names:
             continue
-        if name in all_module_names :
+        if name in all_module_names:
             m = get_module(model, name)
             if len(list(m.children())) == 0 and type(m) not in supported_types:
                 logger.warning(f"{name} is not supported in current scheme, ignoring its setting in `layer_config`")
                 continue
 
-
         regex = re.compile(name)
         matched = [ln for ln in all_supported_layer_names if regex.search(ln)]
         if not matched:

From 87d36945c76185131ea0b88e16646e2b6c29c1cc Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 9 Oct 2025 21:07:26 +0800
Subject: [PATCH 41/88] fix one bug

---
 auto_round/schemes.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 2c087285e..8932d7b3e 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -250,7 +250,8 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
     if isinstance(scheme, str):
         return ""
     for key, val in PRESET_SCHEMES.items():
-        if not key.upper().startswith("GGUF"):
+        # For q40 or q4_1 we only support it with str scheme， otherwise it will be matched incorrectly with W4G32
+        if not key.upper().startswith("GGUF") and ("0" in key or "1" in key):
             continue
         equal = True
         for scheme_key in val.keys():

From 3855c8f10687c26305c4ff7478ce5089cb9b56b5 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 10 Oct 2025 09:52:49 +0800
Subject: [PATCH 42/88] fix

---
 auto_round/schemes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 8932d7b3e..5cd959363 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -251,7 +251,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
         return ""
     for key, val in PRESET_SCHEMES.items():
         # For q40 or q4_1 we only support it with str scheme， otherwise it will be matched incorrectly with W4G32
-        if not key.upper().startswith("GGUF") and ("0" in key or "1" in key):
+        if not key.upper().startswith("GGUF") or  ("0" in key or "1" in key):
             continue
         equal = True
         for scheme_key in val.keys():

From d3e28c27207c43e863485e96b4fc21295496bedd Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 10 Oct 2025 01:53:35 +0000
Subject: [PATCH 43/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/schemes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 5cd959363..c305646a8 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -251,7 +251,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
         return ""
     for key, val in PRESET_SCHEMES.items():
         # For q40 or q4_1 we only support it with str scheme， otherwise it will be matched incorrectly with W4G32
-        if not key.upper().startswith("GGUF") or  ("0" in key or "1" in key):
+        if not key.upper().startswith("GGUF") or ("0" in key or "1" in key):
             continue
         equal = True
         for scheme_key in val.keys():

From 2d557d095e2ac891948aac4e35870c6eb4513007 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 10 Oct 2025 16:06:45 +0800
Subject: [PATCH 44/88] set up the first version, there are many details to be
 handled

---
 auto_round/auto_schemes/__init__.py        | 10 ++--
 auto_round/auto_schemes/gen_auto_scheme.py | 28 ++++++---
 auto_round/auto_schemes/utils.py           | 60 ++++++++++++-------
 auto_round/compressors/base.py             | 69 ++++++++++++++++------
 auto_round/schemes.py                      |  7 ++-
 auto_round/utils.py                        |  8 +--
 test/test_cuda/test_auto_scheme.py         |  8 ++-
 7 files changed, 132 insertions(+), 58 deletions(-)

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index 285c68666..de6ad8073 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-AUTO_SCHEMES_ALGS = {}
+AUTO_SCHEMES_METHODS = {}
 
 
-def register_scheme_algs(names):
+def register_scheme_methods(names):
     """Class decorator to register a mixed precision algorithm to the registry.
 
     Decorator function used before a Pattern subclass.
@@ -30,10 +30,12 @@ def register_scheme_algs(names):
     def register(alg):
         if isinstance(names, (tuple, list)):
             for name in names:
-                AUTO_SCHEMES_ALGS[name] = alg
+                AUTO_SCHEMES_METHODS[name] = alg
         else:
-            AUTO_SCHEMES_ALGS[names] = alg
+            AUTO_SCHEMES_METHODS[names] = alg
 
         return alg
 
     return register
+
+import auto_round.auto_schemes.haha
diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index f4b668f17..c6ca1f6b6 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -19,44 +19,58 @@
 from auto_round import AutoScheme
 from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
 from auto_round.logger import logger
-
+from auto_round.auto_schemes import AUTO_SCHEMES_METHODS
 
 class GenScheme:
     """Generate and validate quantization schemes for model layers."""
 
     def __init__(
         self,
-        auto_scheme: AutoScheme,
+        auto_scheme: AutoScheme, # TODO support shared layer
         model: torch.nn.Module,
         quant_layer_names: Iterable[str],
         fixed_layer_scheme: dict[str, dict],
-        scale_dtype: str = "fp16",
-        dataset: str = "pile-10k",
+        dataset: str = "pile-10k", # TODO use auto-round dataset
+        tokenizer=None,
     ):
         self.auto_scheme = auto_scheme
         self.model = model
+        self.tokenizer = tokenizer
         self.quant_layer_names = quant_layer_names
         self.fixed_layer_scheme = fixed_layer_scheme
-        self.scale_dtype = scale_dtype
         self.dataset = dataset
 
         self._check_configs()
 
     def _check_configs(self) -> None:
         """Validate auto_scheme configuration and ensure avg_bits target is valid."""
+        if isinstance(self.model, torch.nn.Module) and self.tokenizer is None:
+            raise ValueError("tokenizer must not be None if model is nn.Module")
+
         if not isinstance(self.dataset, str):
             raise TypeError("`dataset` must be a string, got {type(self.dataset).__name__}.")
 
         min_avg_bit, max_avg_bit = self.compute_avg_bit_range()
         target = self.auto_scheme.avg_bits
 
-        logger.info("Average bits range: [%.2f, %.2f], target = %.2f", min_avg_bit, max_avg_bit, target)
+        logger.info("Average bits range: [%.3f, %.3f], target = %.3f", min_avg_bit, max_avg_bit, target)
 
         if not (min_avg_bit <= target <= max_avg_bit):
             raise ValueError(
-                f"Target avg_bits={target:.2f} is outside the valid range " f"[{min_avg_bit:.2f}, {max_avg_bit:.2f}]."
+                f"Target avg_bits={target:.3f} is outside the valid range " f"[{min_avg_bit:.3f}, {max_avg_bit:.3f}]."
             )
 
+    def get_layer_config(self):
+        method_name = self.auto_scheme.method
+        method_func = AUTO_SCHEMES_METHODS[method_name]
+        layer_config = method_func(self.auto_scheme,
+        self.model,
+        self.quant_layer_names,
+        self.fixed_layer_scheme,
+        self.dataset,
+        self.tokenizer)
+        return layer_config
+
     def compute_avg_bit_range(self) -> tuple[float, float]:
         """Compute the min and max average bitwidths among candidate quantization options."""
         avg_bits = [
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 3122f1600..0e7e1dc71 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -11,21 +11,21 @@
 # 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 dataclasses import asdict
+from dataclasses import asdict, fields
 from typing import Iterable, Union
 
 import torch
 
 from auto_round.low_cpu_mem import get_module
-from auto_round.schemes import preset_name_to_scheme
-from auto_round.utils import get_layer_features
+from auto_round.schemes import preset_name_to_scheme, QuantizationScheme
+from auto_round.utils import get_layer_features, check_to_quantized
 
 
 def apply_quant_scheme(
     model: torch.nn.Module,
     quant_layer_names: Iterable[str],
     fixed_layer_scheme: dict[str, dict],
-    scheme: Union[str, dict],
+    scheme: Union[str, dict], #TODO add scale_dtype
 ) -> None:
     """Apply a quantization scheme to each quantized layer.
 
@@ -47,27 +47,17 @@ def apply_quant_scheme(
 
 def remove_quant_scheme(
     model: torch.nn.Module,
-    quant_layer_names: Iterable[str],
-    fixed_layer_scheme: dict[str, dict],
-    scheme: Union[str, dict],
 ) -> None:
     """Remove attributes corresponding to the applied quantization scheme.
 
     Args:
         model: The model whose layers are to be cleared.
-        scheme: The scheme preset name or dictionary previously applied.
-        quant_layer_names: Iterable of layer names to clear.
-        fixed_layer_scheme: Dictionary of fixed per-layer quantization schemes.
     """
-    for name in quant_layer_names:
-        layer_scheme = fixed_layer_scheme.get(name, scheme)
-        if isinstance(layer_scheme, str):
-            layer_scheme = asdict(preset_name_to_scheme(layer_scheme))
-
-        module = get_module(model, name)
-        for key in layer_scheme.keys():
-            if hasattr(module, key):
-                delattr(module, key)
+    scheme_keys = [f.name for f in fields(QuantizationScheme)] + ["scale_dtype"]
+    for n,m in model.named_modules():
+        for key in scheme_keys:
+            if hasattr(m, key):
+                delattr(m, key)
 
 
 def compute_avg_bits_for_scheme(
@@ -108,11 +98,39 @@ def compute_avg_bits_for_scheme(
     avg_bits = float(total_quantized_bits) / total_params
 
     if scheme is not None:
-        remove_quant_scheme(model, quant_layer_names, fixed_layer_scheme, scheme)
+        remove_quant_scheme(model)
+
+    return avg_bits, total_quantized_bits
+
+def compute_avg_bits_for_model(model:torch.nn.Module, ignore_scale_zp_bits: bool = False):
+    """Compute the average and total bit usage for the entire model.
+
+    Args:
+        model: The model to analyze.
+        ignore_scale_zp_bits: If True, ignores overhead from scale and zero-points.
+        if scheme is not None:
+        apply_quant_scheme(model, quant_layer_names, fixed_layer_scheme, scheme)
+    """
+
+    total_params = 0
+    total_quantized_bits = 0
+
+    for n,module in model.named_modules():
+        if not  hasattr(module, "bits"):
+            continue
+        if not hasattr(module, "weight"):
+            continue
+        total_params += module.weight.numel()
+        layer_bits, _ = compute_layer_bits(module, ignore_scale_zp_bits)
+        total_quantized_bits += layer_bits
+
+    avg_bits = float(total_quantized_bits) / total_params
+
 
     return avg_bits, total_quantized_bits
 
 
+
 def compute_layer_bits(
     layer: torch.nn.Module,
     ignore_scale_zp_bits: bool = False,
@@ -135,7 +153,7 @@ def compute_layer_bits(
 
     # Unquantized layer or ignoring scale/zp overhead
     if weight_bits >= 16 or ignore_scale_zp_bits:
-        if super_weight_bits is not None:  # reset gguf 16 bits to 32 bits
+        if super_weight_bits is not None:  # reset gguf 16 bits to 32 bits, TODO gguf q4_0, q4_1 may have bug
             return 32 * n_param, 32
         return weight_bits * n_param, 16.0
 
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 8c74dff86..bb1528653 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -202,10 +202,32 @@ def __init__(
             ...     # ...
             ... }
         """
-        if isinstance(scheme, AutoScheme):  # TODO  AutoScheme could also be patched by group_size, etc
-            self.scheme = self._parse_and_set_scheme(scheme.options[0], kwargs)
+
+        if isinstance(scheme, AutoScheme):
+            if len(scheme.options)<=0:
+                raise ValueError("options of AutoScheme must not be empty")
+            options=[]
+            for option in scheme.options:
+                new_option = self._parse_and_set_scheme(option, kwargs)
+                options.append(new_option)
+            scheme.options = options
+            for opt in options:
+                if isinstance(opt, str) and opt=="BF16":
+                    continue
+                if isinstance(opt, QuantizationScheme):
+                    if opt.bits>=16 and (opt.act_bits is None or opt.act_bits>=16):
+                        continue
+                self.scheme= opt # Choose the first one that not 16 bits
+            self.is_auto_scheme = True
+
+
         else:
             self.scheme = self._parse_and_set_scheme(scheme, kwargs)
+            self.is_auto_scheme = False
+
+        scheme_keys = [f.name for f in fields(QuantizationScheme)]
+        for key in scheme_keys:
+            kwargs.pop(key, None)
 
         gguf_scheme_name = get_gguf_scheme(self.scheme)
         # GGUF uses fp32 scale dtype as default
@@ -293,7 +315,7 @@ def __init__(
             if self.mllm:
                 logger.info("AutoScheme with MLLM is not supported yet.")
                 sys.exit(1)
-            layer_config, _ = set_layer_config(
+            layer_config, self.has_qlayer_outside_block  = set_layer_config(
                 self.model,
                 self.layer_config,
                 self.scheme,
@@ -311,7 +333,8 @@ def __init__(
             # mainly using quant_layers and fixed by users
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
-            gen_scheme = GenScheme(scheme, self.model, quant_layer_names, fixed_layer_scheme, self.scale_dtype, dataset)
+            gen_scheme = GenScheme(scheme, self.model, quant_layer_names, fixed_layer_scheme, dataset,tokenizer=self.tokenizer)
+            self.layer_config = gen_scheme.get_layer_config()
 
         # Set device, must place after model loading
         self._set_device(device_map)
@@ -428,7 +451,7 @@ def _parse_and_set_scheme(self, scheme: Union[str, dict, QuantizationScheme], kw
                 setattr(self, key, kwargs[key])
             else:
                 setattr(self, key, scheme.get(key, None))
-            kwargs.pop(key, None)
+            # kwargs.pop(key, None)
         if self.act_dynamic is None:
             self.act_dynamic = True
 
@@ -1588,19 +1611,29 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
         self.model = _handle_moe_model(self.model, formats=formats)
 
         # TODO check scale_dtype
-        self.layer_config, self.has_qlayer_outside_block = set_layer_config(
-            self.model,
-            self.layer_config,
-            self.scheme,
-            self.scale_dtype,
-            self.supported_types,
-            self.inner_supported_types,
-            self.quant_block_list,
-            self.fp_layers,
-            self.quant_lm_head,
-            enable_gguf_official_mixed=True,
-            is_mllm=self.mllm,
-        )
+        if not self.is_auto_scheme:
+            self.layer_config, self.has_qlayer_outside_block = set_layer_config(
+                self.model,
+                self.layer_config,
+                self.scheme,
+                self.scale_dtype,
+                self.supported_types,
+                self.inner_supported_types,
+                self.quant_block_list,
+                self.fp_layers,
+                self.quant_lm_head,
+                enable_gguf_official_mixed=True,
+                is_mllm=self.mllm,
+            )
+        else:
+            for n,scheme in self.layer_config.items():
+                module = get_module(self.model, n)
+                if not isinstance(scheme,dict):
+                    raise ValueError("scheme return by scheme should be dict")
+                for key,item in scheme.items():
+                    setattr(module, key, item)
+                # set_extra scale_dtype
+                module.scale_dtype = self.scale_dtype
 
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 5cd959363..09a919445 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -214,7 +214,7 @@ def is_preset_scheme(name: str) -> bool:
 BF16 = QuantizationScheme.from_dict(
     {
         "bits": 16,
-        "group_size": 0,
+        "group_size": 128,
         "data_type": "fp",
         "act_bits": 16,
         "act_data_type": "fp",
@@ -265,8 +265,11 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 
 @dataclass
 class AutoScheme:
-    options: Optional[Iterable[QuantizationScheme | str]]
+    options: Union[list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
     avg_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
     ignore_scale_zp_bits = False
+    nsamples = None
+    seqlen = None
+    dataset: Optional[str] = None # Import Notice no comma for each item
\ No newline at end of file
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 1e4a5c131..deee6805d 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2861,7 +2861,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     default_dict["scale_dtype"] = default_scale_dtype
     for cfg in layer_config.values():
         for key in scheme_keys:
-            cfg.setdefault(key, default_dict.copy().get(key))
+            cfg.setdefault(key, copy.deepcopy(default_dict.get(key)))
 
     # 5. collect supported modules
     gguf_name = get_gguf_scheme(default_scheme)
@@ -2913,21 +2913,21 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         )
 
     if lm_head_name not in layer_config and quant_lm_head:
-        layer_config[lm_head_name] = default_dict.copy()
+        layer_config[lm_head_name] = copy.deepcopy(default_dict)
 
     # 8. enforce shape divisibility for int weight-only
     if default_dict["data_type"] == "int" and default_dict["act_bits"] >= 16 and not gguf_name:
         for n, m in model.named_modules():
             if type(m) in supported_types or m.__class__.__name__ in inner_supported_types:
                 if m.weight.shape[0] % 32 or m.weight.shape[1] % 32:
-                    layer_config.setdefault(n, default_dict.copy())
+                    layer_config.setdefault(n, copy.deepcopy(default_dict))
                     layer_config[n].update({"bits": 16, "data_type": "fp", "fixed_by_user": True})
                     logger.warning_once(f"{n} skipped quantization (shape not divisible by 32).")
 
     # 9. block layers: mark as in_blocks=True
     for name in get_layer_names_in_block(model, supported_types, quant_block_list, inner_supported_types):
         if name not in layer_config:
-            layer_config[name] = default_dict.copy()
+            layer_config[name] = copy.deepcopy(default_dict)
             layer_config[name]["fixed_by_user"] = False
         layer_config[name]["in_blocks"] = True
 
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index b9fffdee9..a813e0801 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -4,6 +4,8 @@
 import sys
 import unittest
 
+from auto_round.auto_schemes.utils import compute_avg_bits_for_model
+
 sys.path.insert(0, "../..")
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
@@ -23,5 +25,7 @@ def tearDownClass(self):
     def test_auto_scheme(self):
         model_name = "facebook/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1)
-        ar.quantize_and_save(self.save_dir)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
+        model, layer_config = ar.quantize()
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        assert (2.9 < avg_bits <= 3.0)

From cedad472cdf3653000dd94ebdb10a2d2db3c39b6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 10 Oct 2025 08:08:42 +0000
Subject: [PATCH 45/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/__init__.py        |  1 +
 auto_round/auto_schemes/gen_auto_scheme.py | 16 +++++++--------
 auto_round/auto_schemes/utils.py           | 17 ++++++++--------
 auto_round/compressors/base.py             | 23 +++++++++++-----------
 auto_round/schemes.py                      |  2 +-
 test/test_cuda/test_auto_scheme.py         |  2 +-
 6 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index de6ad8073..550458961 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -38,4 +38,5 @@ def register(alg):
 
     return register
 
+
 import auto_round.auto_schemes.haha
diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index c6ca1f6b6..cf96c06a9 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -17,20 +17,21 @@
 import torch
 
 from auto_round import AutoScheme
+from auto_round.auto_schemes import AUTO_SCHEMES_METHODS
 from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
 from auto_round.logger import logger
-from auto_round.auto_schemes import AUTO_SCHEMES_METHODS
+
 
 class GenScheme:
     """Generate and validate quantization schemes for model layers."""
 
     def __init__(
         self,
-        auto_scheme: AutoScheme, # TODO support shared layer
+        auto_scheme: AutoScheme,  # TODO support shared layer
         model: torch.nn.Module,
         quant_layer_names: Iterable[str],
         fixed_layer_scheme: dict[str, dict],
-        dataset: str = "pile-10k", # TODO use auto-round dataset
+        dataset: str = "pile-10k",  # TODO use auto-round dataset
         tokenizer=None,
     ):
         self.auto_scheme = auto_scheme
@@ -63,12 +64,9 @@ def _check_configs(self) -> None:
     def get_layer_config(self):
         method_name = self.auto_scheme.method
         method_func = AUTO_SCHEMES_METHODS[method_name]
-        layer_config = method_func(self.auto_scheme,
-        self.model,
-        self.quant_layer_names,
-        self.fixed_layer_scheme,
-        self.dataset,
-        self.tokenizer)
+        layer_config = method_func(
+            self.auto_scheme, self.model, self.quant_layer_names, self.fixed_layer_scheme, self.dataset, self.tokenizer
+        )
         return layer_config
 
     def compute_avg_bit_range(self) -> tuple[float, float]:
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 0e7e1dc71..06eedcc0d 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -17,15 +17,15 @@
 import torch
 
 from auto_round.low_cpu_mem import get_module
-from auto_round.schemes import preset_name_to_scheme, QuantizationScheme
-from auto_round.utils import get_layer_features, check_to_quantized
+from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
+from auto_round.utils import check_to_quantized, get_layer_features
 
 
 def apply_quant_scheme(
     model: torch.nn.Module,
     quant_layer_names: Iterable[str],
     fixed_layer_scheme: dict[str, dict],
-    scheme: Union[str, dict], #TODO add scale_dtype
+    scheme: Union[str, dict],  # TODO add scale_dtype
 ) -> None:
     """Apply a quantization scheme to each quantized layer.
 
@@ -54,7 +54,7 @@ def remove_quant_scheme(
         model: The model whose layers are to be cleared.
     """
     scheme_keys = [f.name for f in fields(QuantizationScheme)] + ["scale_dtype"]
-    for n,m in model.named_modules():
+    for n, m in model.named_modules():
         for key in scheme_keys:
             if hasattr(m, key):
                 delattr(m, key)
@@ -102,7 +102,8 @@ def compute_avg_bits_for_scheme(
 
     return avg_bits, total_quantized_bits
 
-def compute_avg_bits_for_model(model:torch.nn.Module, ignore_scale_zp_bits: bool = False):
+
+def compute_avg_bits_for_model(model: torch.nn.Module, ignore_scale_zp_bits: bool = False):
     """Compute the average and total bit usage for the entire model.
 
     Args:
@@ -115,8 +116,8 @@ def compute_avg_bits_for_model(model:torch.nn.Module, ignore_scale_zp_bits: bool
     total_params = 0
     total_quantized_bits = 0
 
-    for n,module in model.named_modules():
-        if not  hasattr(module, "bits"):
+    for n, module in model.named_modules():
+        if not hasattr(module, "bits"):
             continue
         if not hasattr(module, "weight"):
             continue
@@ -126,11 +127,9 @@ def compute_avg_bits_for_model(model:torch.nn.Module, ignore_scale_zp_bits: bool
 
     avg_bits = float(total_quantized_bits) / total_params
 
-
     return avg_bits, total_quantized_bits
 
 
-
 def compute_layer_bits(
     layer: torch.nn.Module,
     ignore_scale_zp_bits: bool = False,
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index bb1528653..aea6f420a 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -204,23 +204,22 @@ def __init__(
         """
 
         if isinstance(scheme, AutoScheme):
-            if len(scheme.options)<=0:
+            if len(scheme.options) <= 0:
                 raise ValueError("options of AutoScheme must not be empty")
-            options=[]
+            options = []
             for option in scheme.options:
                 new_option = self._parse_and_set_scheme(option, kwargs)
                 options.append(new_option)
             scheme.options = options
             for opt in options:
-                if isinstance(opt, str) and opt=="BF16":
+                if isinstance(opt, str) and opt == "BF16":
                     continue
                 if isinstance(opt, QuantizationScheme):
-                    if opt.bits>=16 and (opt.act_bits is None or opt.act_bits>=16):
+                    if opt.bits >= 16 and (opt.act_bits is None or opt.act_bits >= 16):
                         continue
-                self.scheme= opt # Choose the first one that not 16 bits
+                self.scheme = opt  # Choose the first one that not 16 bits
             self.is_auto_scheme = True
 
-
         else:
             self.scheme = self._parse_and_set_scheme(scheme, kwargs)
             self.is_auto_scheme = False
@@ -315,7 +314,7 @@ def __init__(
             if self.mllm:
                 logger.info("AutoScheme with MLLM is not supported yet.")
                 sys.exit(1)
-            layer_config, self.has_qlayer_outside_block  = set_layer_config(
+            layer_config, self.has_qlayer_outside_block = set_layer_config(
                 self.model,
                 self.layer_config,
                 self.scheme,
@@ -333,7 +332,9 @@ def __init__(
             # mainly using quant_layers and fixed by users
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
-            gen_scheme = GenScheme(scheme, self.model, quant_layer_names, fixed_layer_scheme, dataset,tokenizer=self.tokenizer)
+            gen_scheme = GenScheme(
+                scheme, self.model, quant_layer_names, fixed_layer_scheme, dataset, tokenizer=self.tokenizer
+            )
             self.layer_config = gen_scheme.get_layer_config()
 
         # Set device, must place after model loading
@@ -1626,11 +1627,11 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
                 is_mllm=self.mllm,
             )
         else:
-            for n,scheme in self.layer_config.items():
+            for n, scheme in self.layer_config.items():
                 module = get_module(self.model, n)
-                if not isinstance(scheme,dict):
+                if not isinstance(scheme, dict):
                     raise ValueError("scheme return by scheme should be dict")
-                for key,item in scheme.items():
+                for key, item in scheme.items():
                     setattr(module, key, item)
                 # set_extra scale_dtype
                 module.scale_dtype = self.scale_dtype
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 765b7e447..24688eeed 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -272,4 +272,4 @@ class AutoScheme:
     ignore_scale_zp_bits = False
     nsamples = None
     seqlen = None
-    dataset: Optional[str] = None # Import Notice no comma for each item
\ No newline at end of file
+    dataset: Optional[str] = None  # Import Notice no comma for each item
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index a813e0801..5cb543ca6 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -28,4 +28,4 @@ def test_auto_scheme(self):
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
         model, layer_config = ar.quantize()
         avg_bits, _ = compute_avg_bits_for_model(model)
-        assert (2.9 < avg_bits <= 3.0)
+        assert 2.9 < avg_bits <= 3.0

From 0c3a0e20b0e6ecfae3044d24ea4490ad37ab78cd Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 10 Oct 2025 17:26:13 +0800
Subject: [PATCH 46/88] fix one bug

---
 auto_round/auto_schemes/__init__.py |  2 +-
 auto_round/compressors/base.py      | 34 ++++++++++++++++++++++-------
 test/test_cuda/test_auto_scheme.py  | 21 ++++++++++++++----
 3 files changed, 44 insertions(+), 13 deletions(-)

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index 550458961..35664c1db 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -39,4 +39,4 @@ def register(alg):
     return register
 
 
-import auto_round.auto_schemes.haha
+import auto_round.auto_schemes.haha # pylint: disable=E0611
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index aea6f420a..21d7d32c0 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -218,6 +218,11 @@ def __init__(
                     if opt.bits >= 16 and (opt.act_bits is None or opt.act_bits >= 16):
                         continue
                 self.scheme = opt  # Choose the first one that not 16 bits
+                break
+
+            # apply scheme to set default bits
+            self._parse_and_set_scheme(self.scheme, kwargs)
+
             self.is_auto_scheme = True
 
         else:
@@ -1627,14 +1632,27 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
                 is_mllm=self.mllm,
             )
         else:
-            for n, scheme in self.layer_config.items():
-                module = get_module(self.model, n)
-                if not isinstance(scheme, dict):
-                    raise ValueError("scheme return by scheme should be dict")
-                for key, item in scheme.items():
-                    setattr(module, key, item)
-                # set_extra scale_dtype
-                module.scale_dtype = self.scale_dtype
+            # for n, scheme in self.layer_config.items():
+            #     module = get_module(self.model, n)
+            #     if not isinstance(scheme, dict):
+            #         raise ValueError("scheme return by scheme should be dict")
+            #     for key, item in scheme.items():
+            #         setattr(module, key, item)
+            #     # set_extra scale_dtype
+            #     module.scale_dtype = self.scale_dtype
+            self.layer_config, self.has_qlayer_outside_block = set_layer_config(
+                self.model,
+                self.layer_config,
+                self.scheme,
+                self.scale_dtype,
+                self.supported_types,
+                self.inner_supported_types,
+                self.quant_block_list,
+                self.fp_layers,
+                self.quant_lm_head,
+                enable_gguf_official_mixed=False,
+                is_mllm=self.mllm,
+            )
 
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 5cb543ca6..f5833f006 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -5,6 +5,7 @@
 import unittest
 
 from auto_round.auto_schemes.utils import compute_avg_bits_for_model
+from auto_round.eval.evaluation import simple_evaluate
 
 sys.path.insert(0, "../..")
 
@@ -22,10 +23,22 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
+    # def test_auto_scheme(self):
+    #     model_name = "facebook/opt-125m"
+    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
+    #     model, layer_config = ar.quantize()
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert 2.9 < avg_bits <= 3.0
+
     def test_auto_scheme(self):
         model_name = "facebook/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
-        model, layer_config = ar.quantize()
-        avg_bits, _ = compute_avg_bits_for_model(model)
-        assert 2.9 < avg_bits <= 3.0
+        ar = AutoRound(model=model_name, scheme=scheme)
+        ar.quantize_and_save(self.save_dir)
+        model_args = f"pretrained={self.save_dir}"
+        result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
+        print(result["results"]["lambada_openai"]["acc,none"])
+        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+

From cced6d84d84ad081d317590d04560e6a2d8b032b Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 10 Oct 2025 09:27:00 +0000
Subject: [PATCH 47/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/__init__.py | 2 +-
 test/test_cuda/test_auto_scheme.py  | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index 35664c1db..6ac6723a1 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -39,4 +39,4 @@ def register(alg):
     return register
 
 
-import auto_round.auto_schemes.haha # pylint: disable=E0611
+import auto_round.auto_schemes.haha  # pylint: disable=E0611
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index f5833f006..490b79c64 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -41,4 +41,3 @@ def test_auto_scheme(self):
         result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
         print(result["results"]["lambada_openai"]["acc,none"])
         self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
-

From 58d5ae21f5d964500f6431f09d40c91f1e61bc8c Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 10 Oct 2025 17:27:34 +0800
Subject: [PATCH 48/88] uncomment ut

---
 test/test_cuda/test_auto_scheme.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index f5833f006..35d672342 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -23,14 +23,14 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    # def test_auto_scheme(self):
-    #     model_name = "facebook/opt-125m"
-    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
-    #     model, layer_config = ar.quantize()
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert 2.9 < avg_bits <= 3.0
+    def test_auto_scheme(self):
+        model_name = "facebook/opt-125m"
+        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
+        model, layer_config = ar.quantize()
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert 2.9 < avg_bits <= 3.0
 
     def test_auto_scheme(self):
         model_name = "facebook/opt-125m"

From ea489c35d163f2b01872142363bd4c70fd8207f1 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Fri, 10 Oct 2025 17:29:28 +0800
Subject: [PATCH 49/88] rename functions

---
 test/test_cuda/test_auto_scheme.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 4b0148df3..a2a0c55fc 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -23,7 +23,7 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    def test_auto_scheme(self):
+    def test_avg_bits(self):
         model_name = "facebook/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
@@ -32,7 +32,7 @@ def test_auto_scheme(self):
         print(avg_bits)
         assert 2.9 < avg_bits <= 3.0
 
-    def test_auto_scheme(self):
+    def test_auto_scheme_export(self):
         model_name = "facebook/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
         ar = AutoRound(model=model_name, scheme=scheme)

From f74fcb49131787a7d3539782ebb0c1bb03a1ad71 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 11 Oct 2025 01:43:22 +0000
Subject: [PATCH 50/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__init__.py  | 1 +
 auto_round/autoround.py | 1 -
 auto_round/utils.py     | 2 ++
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/auto_round/__init__.py b/auto_round/__init__.py
index e3572ef1a..268065ba4 100644
--- a/auto_round/__init__.py
+++ b/auto_round/__init__.py
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from auto_round.autoround import AutoRound
+
 # support for old api
 from auto_round.autoround import AutoRoundLLM, AutoRoundMLLM, AutoRoundAdam, AutoRoundDiffusion
 from auto_round.schemes import QuantizationScheme, AutoScheme
diff --git a/auto_round/autoround.py b/auto_round/autoround.py
index 090e3bff2..a335b343c 100644
--- a/auto_round/autoround.py
+++ b/auto_round/autoround.py
@@ -26,7 +26,6 @@
     MLLMCompressor,
 )
 from auto_round.logger import deprecated, logger
-
 from auto_round.schemes import AutoScheme, QuantizationScheme
 from auto_round.utils import is_diffusion_model, is_mllm_model
 
diff --git a/auto_round/utils.py b/auto_round/utils.py
index ecce4f505..0b61cb9dc 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -3006,6 +3006,8 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
 
     dispatch_layer_config(layer_config)
     return layer_config, has_qlayer_outside_block
+
+
 def check_diffusers_installed():  # pragma: no cover
     try:
         import diffusers  # noqa: F401

From 9cfa4e5869f62ee99b74e1712c44d59f7c618e5c Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Sat, 11 Oct 2025 17:51:39 +0800
Subject: [PATCH 51/88] update

---
 auto_round/auto_schemes/__init__.py        |  2 +-
 auto_round/auto_schemes/gen_auto_scheme.py |  6 +++++
 auto_round/compressors/base.py             | 10 +++++++--
 auto_round/data_type/int.py                |  1 +
 auto_round/data_type/mxfp.py               |  4 ++--
 auto_round/schemes.py                      |  5 ++++-
 test/test_cuda/test_auto_scheme.py         | 26 +++++++++++++++++++---
 7 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_schemes/__init__.py
index 6ac6723a1..e0e5ccb66 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_schemes/__init__.py
@@ -39,4 +39,4 @@ def register(alg):
     return register
 
 
-import auto_round.auto_schemes.haha  # pylint: disable=E0611
+import auto_round.auto_schemes.haha  # pylint: disable=E0611,E0401
diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index cf96c06a9..1903f6519 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -55,6 +55,12 @@ def _check_configs(self) -> None:
         target = self.auto_scheme.avg_bits
 
         logger.info("Average bits range: [%.3f, %.3f], target = %.3f", min_avg_bit, max_avg_bit, target)
+        if abs(target-min_avg_bit)<1e-3 or abs(target-max_avg_bit)<1e-3:
+            if target <=min_avg_bit:
+                target = min_avg_bit
+            else:
+                target = max_avg_bit
+            self.auto_scheme.avg_bits = target
 
         if not (min_avg_bit <= target <= max_avg_bit):
             raise ValueError(
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index af008861e..f624ba54c 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -335,12 +335,18 @@ def __init__(
                 is_mllm=self.mllm,
             )
             quant_layer_names = layer_config.keys()
-            fixed_layer_scheme = {k: v for k, v in layer_config.items() if v.get("fixed_by_user", False)}
+            scheme_keys = {f.name for f in fields(QuantizationScheme)}
+            fixed_layer_scheme_new = {
+                k: {key: v[key] for key in scheme_keys & v.keys()}
+                for k, v in layer_config.items()
+                if v.get("fixed_by_user", False)
+            }
+
             # mainly using quant_layers and fixed by users
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
             gen_scheme = GenScheme(
-                scheme, self.model, quant_layer_names, fixed_layer_scheme, dataset, tokenizer=self.tokenizer
+                scheme, self.model, quant_layer_names, fixed_layer_scheme_new, dataset, tokenizer=self.tokenizer
             )
             self.layer_config = gen_scheme.get_layer_config()
 
diff --git a/auto_round/data_type/int.py b/auto_round/data_type/int.py
index 5b151fdfe..637485470 100644
--- a/auto_round/data_type/int.py
+++ b/auto_round/data_type/int.py
@@ -19,6 +19,7 @@
 
 
 @register_dtype("int_sym")
+@torch.compile
 def quant_tensor_sym(
     tensor,
     bits=4,
diff --git a/auto_round/data_type/mxfp.py b/auto_round/data_type/mxfp.py
index 862ff0a9a..b93628fc2 100644
--- a/auto_round/data_type/mxfp.py
+++ b/auto_round/data_type/mxfp.py
@@ -76,7 +76,7 @@ def quant_element(tensor, ebits, mbits, max_norm, mantissa_rounding="even"):
     tensor = torch.clamp(tensor, min=-max_norm, max=max_norm)
     return tensor
 
-
+@torch.compile
 def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs):
     """Quantize the given tensor using the specified parameters.
 
@@ -126,7 +126,7 @@ def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_roundin
     tensor = revert_tensor_by_pad(tensor, orig_shape=orig_shape, pad_len=pad_len)
     return tensor.to(orig_dtype), shared_exp.to(orig_dtype), None
 
-
+@torch.compile
 def quant_mx_rceil(
     tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs
 ):
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 24688eeed..ccee9461c 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -265,7 +265,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 
 @dataclass
 class AutoScheme:
-    options: Union[list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
+    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
     avg_bits: float
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
@@ -273,3 +273,6 @@ class AutoScheme:
     nsamples = None
     seqlen = None
     dataset: Optional[str] = None  # Import Notice no comma for each item
+    def __post_init__(self):
+        if isinstance(self.options,str):
+            self.options = self.options.split(",")
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index a2a0c55fc..0956f24fe 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,11 +3,12 @@
 import shutil
 import sys
 import unittest
+sys.path.insert(0, "../..")
 
 from auto_round.auto_schemes.utils import compute_avg_bits_for_model
 from auto_round.eval.evaluation import simple_evaluate
+from auto_round.utils import get_module
 
-sys.path.insert(0, "../..")
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 
@@ -24,14 +25,33 @@ def tearDownClass(self):
         shutil.rmtree("runs", ignore_errors=True)
 
     def test_avg_bits(self):
-        model_name = "facebook/opt-125m"
+        model_name = "/models/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, format="fake")
+        user_layer_config = {"model.decoder.layers.10.fc1":{"bits":8,"group_size":32, "sym":False}}
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1,layer_config=user_layer_config)
         model, layer_config = ar.quantize()
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["group_size"], 32)
+        layer = get_module(model, "model.decoder.layers.10.fc1")
+        self.assertEqual(layer.bits, 8)
+        self.assertEqual(layer.sym, False)
+        self.assertEqual(layer.group_size,32)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert 2.9 < avg_bits <= 3.0
 
+    def test_lm_head_and_mix_dtype(self):
+        model_name = "/models/Qwen3-8B"
+        target_bits = 8.192
+        scheme = AutoScheme(avg_bits=target_bits, options=( "MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits-0.1 < avg_bits <= target_bits
+
     def test_auto_scheme_export(self):
         model_name = "facebook/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))

From ac4036ef5ae373e790ce5a7d5352999edd0f3113 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sat, 11 Oct 2025 09:52:44 +0000
Subject: [PATCH 52/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_auto_scheme.py |  4 ++--
 auto_round/data_type/mxfp.py               |  2 ++
 auto_round/schemes.py                      |  3 ++-
 test/test_cuda/test_auto_scheme.py         | 15 +++++++--------
 4 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index 1903f6519..e2fc6eb0d 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -55,8 +55,8 @@ def _check_configs(self) -> None:
         target = self.auto_scheme.avg_bits
 
         logger.info("Average bits range: [%.3f, %.3f], target = %.3f", min_avg_bit, max_avg_bit, target)
-        if abs(target-min_avg_bit)<1e-3 or abs(target-max_avg_bit)<1e-3:
-            if target <=min_avg_bit:
+        if abs(target - min_avg_bit) < 1e-3 or abs(target - max_avg_bit) < 1e-3:
+            if target <= min_avg_bit:
                 target = min_avg_bit
             else:
                 target = max_avg_bit
diff --git a/auto_round/data_type/mxfp.py b/auto_round/data_type/mxfp.py
index b93628fc2..8eb78a8e5 100644
--- a/auto_round/data_type/mxfp.py
+++ b/auto_round/data_type/mxfp.py
@@ -76,6 +76,7 @@ def quant_element(tensor, ebits, mbits, max_norm, mantissa_rounding="even"):
     tensor = torch.clamp(tensor, min=-max_norm, max=max_norm)
     return tensor
 
+
 @torch.compile
 def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs):
     """Quantize the given tensor using the specified parameters.
@@ -126,6 +127,7 @@ def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_roundin
     tensor = revert_tensor_by_pad(tensor, orig_shape=orig_shape, pad_len=pad_len)
     return tensor.to(orig_dtype), shared_exp.to(orig_dtype), None
 
+
 @torch.compile
 def quant_mx_rceil(
     tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index ccee9461c..e8b14f772 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -273,6 +273,7 @@ class AutoScheme:
     nsamples = None
     seqlen = None
     dataset: Optional[str] = None  # Import Notice no comma for each item
+
     def __post_init__(self):
-        if isinstance(self.options,str):
+        if isinstance(self.options, str):
             self.options = self.options.split(",")
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 0956f24fe..e19c1893d 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,16 +3,15 @@
 import shutil
 import sys
 import unittest
+
 sys.path.insert(0, "../..")
 
+from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 from auto_round.auto_schemes.utils import compute_avg_bits_for_model
 from auto_round.eval.evaluation import simple_evaluate
 from auto_round.utils import get_module
 
 
-from auto_round import AutoRound, AutoRoundConfig, AutoScheme
-
-
 class TestAutoScheme(unittest.TestCase):
     @classmethod
     def setUpClass(self):
@@ -27,8 +26,8 @@ def tearDownClass(self):
     def test_avg_bits(self):
         model_name = "/models/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        user_layer_config = {"model.decoder.layers.10.fc1":{"bits":8,"group_size":32, "sym":False}}
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1,layer_config=user_layer_config)
+        user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, layer_config=user_layer_config)
         model, layer_config = ar.quantize()
         self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
         self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
@@ -36,7 +35,7 @@ def test_avg_bits(self):
         layer = get_module(model, "model.decoder.layers.10.fc1")
         self.assertEqual(layer.bits, 8)
         self.assertEqual(layer.sym, False)
-        self.assertEqual(layer.group_size,32)
+        self.assertEqual(layer.group_size, 32)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert 2.9 < avg_bits <= 3.0
@@ -44,13 +43,13 @@ def test_avg_bits(self):
     def test_lm_head_and_mix_dtype(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 8.192
-        scheme = AutoScheme(avg_bits=target_bits, options=( "MXFP4", "W8A16"))
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
         model, layer_config = ar.quantize()
         # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
-        assert target_bits-0.1 < avg_bits <= target_bits
+        assert target_bits - 0.1 < avg_bits <= target_bits
 
     def test_auto_scheme_export(self):
         model_name = "facebook/opt-125m"

From 8a8cb6112f837602d3b7e52cca3626cbe80e8e73 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Sat, 11 Oct 2025 21:00:44 +0800
Subject: [PATCH 53/88] fix

---
 auto_round/data_type/int.py        | 1 -
 auto_round/data_type/mxfp.py       | 2 --
 test/test_cuda/test_auto_scheme.py | 1 +
 3 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/auto_round/data_type/int.py b/auto_round/data_type/int.py
index 637485470..5b151fdfe 100644
--- a/auto_round/data_type/int.py
+++ b/auto_round/data_type/int.py
@@ -19,7 +19,6 @@
 
 
 @register_dtype("int_sym")
-@torch.compile
 def quant_tensor_sym(
     tensor,
     bits=4,
diff --git a/auto_round/data_type/mxfp.py b/auto_round/data_type/mxfp.py
index 8eb78a8e5..862ff0a9a 100644
--- a/auto_round/data_type/mxfp.py
+++ b/auto_round/data_type/mxfp.py
@@ -77,7 +77,6 @@ def quant_element(tensor, ebits, mbits, max_norm, mantissa_rounding="even"):
     return tensor
 
 
-@torch.compile
 def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs):
     """Quantize the given tensor using the specified parameters.
 
@@ -128,7 +127,6 @@ def quant_mx(tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_roundin
     return tensor.to(orig_dtype), shared_exp.to(orig_dtype), None
 
 
-@torch.compile
 def quant_mx_rceil(
     tensor, bits=4, group_size=-1, v=0, max_scale=1.0, mantissa_rounding="even", data_type="mx_fp", **kwargs
 ):
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index e19c1893d..a0e55c225 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -60,3 +60,4 @@ def test_auto_scheme_export(self):
         result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
         print(result["results"]["lambada_openai"]["acc,none"])
         self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+        shutil.rmtree(self.save_dir, ignore_errors=True)

From 0e2be6c7024fda33c8b148e86a3644ca86590e60 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 13 Oct 2025 11:50:12 +0800
Subject: [PATCH 54/88] fix a bug

---
 auto_round/auto_schemes/gen_auto_scheme.py |  2 +-
 auto_round/data_type/gguf.py               |  2 +-
 test/test_cuda/test_auto_scheme.py         | 64 +++++++++++++++++++---
 3 files changed, 59 insertions(+), 9 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index e2fc6eb0d..8557ccabc 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -56,7 +56,7 @@ def _check_configs(self) -> None:
 
         logger.info("Average bits range: [%.3f, %.3f], target = %.3f", min_avg_bit, max_avg_bit, target)
         if abs(target - min_avg_bit) < 1e-3 or abs(target - max_avg_bit) < 1e-3:
-            if target <= min_avg_bit:
+            if abs(target - min_avg_bit) < 1e-3:
                 target = min_avg_bit
             else:
                 target = max_avg_bit
diff --git a/auto_round/data_type/gguf.py b/auto_round/data_type/gguf.py
index 6456b817f..6aa19a3d5 100644
--- a/auto_round/data_type/gguf.py
+++ b/auto_round/data_type/gguf.py
@@ -337,7 +337,7 @@ def quant_tensor_gguf_asym_dq(
         if bits == 2:
             quant_weights = torch.abs(tensor)
         elif bits == 4 or bits == 5:
-            sigma2 = torch.sum(torch.pow(tensor, 2), dim=-1, keepdim=True) / 32  ##Note 32 is different from QK_K
+            sigma2 = torch.sum(torch.pow(tensor, 2), dim=-1, keepdim=True) / 32  # Note 32 is different from QK_K
             av_x = torch.sqrt(sigma2)
             quant_weights = torch.abs(tensor) + av_x
         params = search_kwargs[bits]
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index a0e55c225..d171a667f 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -4,6 +4,8 @@
 import sys
 import unittest
 
+from auto_round.testing_utils import multi_card
+
 sys.path.insert(0, "../..")
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
@@ -23,7 +25,55 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    def test_avg_bits(self):
+    # @multi_card
+    # def test_multi_card(self):
+    #     model_name = "/models/Qwen3-8B"
+    #     target_bits = 4.644
+    #     scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4", "W8A16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+    #     model, layer_config = ar.quantize()
+    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits+1e-3
+
+    def test_min_target_bits(self):
+        model_name = "/models/opt-125m"
+        target_bits = 4.644
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_max_target_bits(self):
+        model_name = "/models/opt-125m"
+        target_bits = 8.211
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_patch_scheme(self):
+        model_name = "/models/opt-125m"
+        target_bits = 5
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, group_size=32)
+        model, layer_config = ar.quantize()
+        for n, m in model.named_modules():
+            if hasattr(m, "group_size"):
+                self.assertEqual(m.group_size, 32)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_layer_config(self):
+        target_bits = 3.0
         model_name = "/models/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
         user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
@@ -38,21 +88,21 @@ def test_avg_bits(self):
         self.assertEqual(layer.group_size, 32)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
-        assert 2.9 < avg_bits <= 3.0
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     def test_lm_head_and_mix_dtype(self):
         model_name = "/models/Qwen3-8B"
-        target_bits = 8.192
+        target_bits = 6
         scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
         model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
-        assert target_bits - 0.1 < avg_bits <= target_bits
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     def test_auto_scheme_export(self):
-        model_name = "facebook/opt-125m"
+        model_name = "/models/opt-125m"
         scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
         ar = AutoRound(model=model_name, scheme=scheme)
         ar.quantize_and_save(self.save_dir)

From 8d854dbf97cb2ae621d980b57bcfb4bdc788005b Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 13 Oct 2025 13:07:41 +0800
Subject: [PATCH 55/88] update

---
 auto_round/__main__.py | 11 +++++++++--
 auto_round/schemes.py  | 11 ++++++-----
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 04d9f4421..c75dc3ce9 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -19,7 +19,7 @@
 
 from auto_round.compressors import BaseCompressor
 from auto_round.eval.eval_cli import EvalArgumentParser, _eval_init, eval, eval_task_by_task
-from auto_round.schemes import PRESET_SCHEMES
+from auto_round.schemes import PRESET_SCHEMES, AutoScheme
 from auto_round.utils import (
     clear_memory,
     get_device_and_parallelism,
@@ -47,7 +47,9 @@ def __init__(self, *args, **kwargs):
             # choices=["W4A16", "W2A16", "W3A16", "W8A16", "MXFP4", "MXFP8", "NVFP4", "FPW8A16", "FP8_STATIC"],
             help="quantization scheme",
         )
-
+        self.add_argument("--avg_bits", default=None, type=float, help="for auto scheme, number of avg weight bits")
+        self.add_argument("--options", default=None, type=str,help="for auto scheme, options for auto scheme, e.g. 'W4A16,W8A16'")
+        self.add_argument("--ignore_scale_zp_bits",  action="store_true", help="for auto scheme whether ignore scale zp bits calculation ")
         self.add_argument("--bits", default=None, type=int, help="number of weight bits")
         self.add_argument("--group_size", default=None, type=int, help="group size")
         self.add_argument("--asym", action="store_true", help="whether to use asym quantization")
@@ -520,6 +522,11 @@ def tune(args):
     #     layer_config[item[0]] = {}
     #     layer_config[item[0]]["bits"] = item[1]
 
+    if args.avg_bits is not None:
+        if args.options is None:
+            raise ValueError("please set --options for auto scheme")
+        scheme = AutoScheme(options=args.options, avg_bits=args.avg_bits,  ignore_scale_zp_bits=args.ignore_scale_zp_bits)
+
     autoround: BaseCompressor = AutoRound(
         model=model_name,
         scheme=scheme,
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index e8b14f772..fa4cbe025 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -265,15 +265,16 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 
 @dataclass
 class AutoScheme:
-    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
     avg_bits: float
+    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
-    ignore_scale_zp_bits = False
-    nsamples = None
-    seqlen = None
+    ignore_scale_zp_bits: bool = False
+    nsamples: Optional[int] = None
+    seqlen: Optional[int] = None
     dataset: Optional[str] = None  # Import Notice no comma for each item
 
     def __post_init__(self):
         if isinstance(self.options, str):
-            self.options = self.options.split(",")
+            options = self.options.upper().replace(" ", "")
+            self.options = options.split(",")

From d7908f461a707538d7682d1fb611a2f9351e2494 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 13 Oct 2025 05:08:32 +0000
Subject: [PATCH 56/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__main__.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index c75dc3ce9..d2ff36912 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -48,8 +48,14 @@ def __init__(self, *args, **kwargs):
             help="quantization scheme",
         )
         self.add_argument("--avg_bits", default=None, type=float, help="for auto scheme, number of avg weight bits")
-        self.add_argument("--options", default=None, type=str,help="for auto scheme, options for auto scheme, e.g. 'W4A16,W8A16'")
-        self.add_argument("--ignore_scale_zp_bits",  action="store_true", help="for auto scheme whether ignore scale zp bits calculation ")
+        self.add_argument(
+            "--options", default=None, type=str, help="for auto scheme, options for auto scheme, e.g. 'W4A16,W8A16'"
+        )
+        self.add_argument(
+            "--ignore_scale_zp_bits",
+            action="store_true",
+            help="for auto scheme whether ignore scale zp bits calculation ",
+        )
         self.add_argument("--bits", default=None, type=int, help="number of weight bits")
         self.add_argument("--group_size", default=None, type=int, help="group size")
         self.add_argument("--asym", action="store_true", help="whether to use asym quantization")
@@ -525,7 +531,9 @@ def tune(args):
     if args.avg_bits is not None:
         if args.options is None:
             raise ValueError("please set --options for auto scheme")
-        scheme = AutoScheme(options=args.options, avg_bits=args.avg_bits,  ignore_scale_zp_bits=args.ignore_scale_zp_bits)
+        scheme = AutoScheme(
+            options=args.options, avg_bits=args.avg_bits, ignore_scale_zp_bits=args.ignore_scale_zp_bits
+        )
 
     autoround: BaseCompressor = AutoRound(
         model=model_name,

From 21dd1c2f48e519e10e4cadded451eb1ad1297f5f Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 13 Oct 2025 17:24:40 +0800
Subject: [PATCH 57/88] support multiple gpu via device_map

---
 auto_round/auto_schemes/gen_auto_scheme.py |   8 +-
 auto_round/auto_schemes/utils.py           | 168 ++++++++++++++++++--
 auto_round/compressors/base.py             |   6 +-
 auto_round/utils.py                        |   6 +-
 auto_round/wrapper.py                      |   2 +-
 test/test_cuda/test_auto_scheme.py         | 172 ++++++++++++---------
 6 files changed, 267 insertions(+), 95 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index 8557ccabc..c5e92ef4c 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from dataclasses import asdict
-from typing import Iterable
+from typing import Iterable, Union
 
 import torch
 
@@ -32,6 +32,7 @@ def __init__(
         quant_layer_names: Iterable[str],
         fixed_layer_scheme: dict[str, dict],
         dataset: str = "pile-10k",  # TODO use auto-round dataset
+        device_map:Union[str,  torch.device, int, dict, None] = None,
         tokenizer=None,
     ):
         self.auto_scheme = auto_scheme
@@ -40,7 +41,7 @@ def __init__(
         self.quant_layer_names = quant_layer_names
         self.fixed_layer_scheme = fixed_layer_scheme
         self.dataset = dataset
-
+        self.device_map = device_map
         self._check_configs()
 
     def _check_configs(self) -> None:
@@ -71,7 +72,8 @@ def get_layer_config(self):
         method_name = self.auto_scheme.method
         method_func = AUTO_SCHEMES_METHODS[method_name]
         layer_config = method_func(
-            self.auto_scheme, self.model, self.quant_layer_names, self.fixed_layer_scheme, self.dataset, self.tokenizer
+            self.auto_scheme, self.model, self.quant_layer_names, self.fixed_layer_scheme,
+            self.dataset, self.tokenizer,device_map=self.device_map,
         )
         return layer_config
 
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 06eedcc0d..7e44eceb6 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -15,17 +15,19 @@
 from typing import Iterable, Union
 
 import torch
+from accelerate import infer_auto_device_map, dispatch_model
+from accelerate.utils import get_balanced_memory
 
 from auto_round.low_cpu_mem import get_module
 from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
-from auto_round.utils import check_to_quantized, get_layer_features
+from auto_round.utils import check_to_quantized, get_layer_features, is_hpex_available
 
 
 def apply_quant_scheme(
-    model: torch.nn.Module,
-    quant_layer_names: Iterable[str],
-    fixed_layer_scheme: dict[str, dict],
-    scheme: Union[str, dict],  # TODO add scale_dtype
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        scheme: Union[str, dict],  # TODO add scale_dtype
 ) -> None:
     """Apply a quantization scheme to each quantized layer.
 
@@ -46,7 +48,7 @@ def apply_quant_scheme(
 
 
 def remove_quant_scheme(
-    model: torch.nn.Module,
+        model: torch.nn.Module,
 ) -> None:
     """Remove attributes corresponding to the applied quantization scheme.
 
@@ -61,11 +63,11 @@ def remove_quant_scheme(
 
 
 def compute_avg_bits_for_scheme(
-    model: torch.nn.Module,
-    quant_layer_names: Iterable[str],
-    fixed_layer_scheme: dict[str, dict],
-    scheme: Union[str, dict, None] = None,
-    ignore_scale_zp_bits: bool = False,
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        scheme: Union[str, dict, None] = None,
+        ignore_scale_zp_bits: bool = False,
 ) -> tuple[float, float]:
     """Compute the average and total bit usage for the given quantization scheme.
 
@@ -131,8 +133,8 @@ def compute_avg_bits_for_model(model: torch.nn.Module, ignore_scale_zp_bits: boo
 
 
 def compute_layer_bits(
-    layer: torch.nn.Module,
-    ignore_scale_zp_bits: bool = False,
+        layer: torch.nn.Module,
+        ignore_scale_zp_bits: bool = False,
 ) -> tuple[int, float]:
     """Compute total and average bitwidth for a single quantized layer.
 
@@ -182,3 +184,143 @@ def compute_layer_bits(
     total_bits = weight_bits * n_param + aux_total_bits
     avg_bits = total_bits / n_param
     return total_bits, avg_bits
+
+
+def parse_all_available_device(device_map: Union[str, torch.device, int, dict, None] = None) -> list:
+    """
+    Parse the device map and return a list of all available devices.
+
+    Supported input formats:
+        - None: Automatically detect all available devices
+        - int: A single device index (e.g., 0)
+        - str: Examples:
+            "cpu"
+            "cuda:0,cuda:1"
+            "0,1" (numeric device indices)
+        - dict: Extract all device values from the dictionary
+        - torch.device: e.g. torch.device("cuda:0")
+
+    Returns:
+        list[str]: Normalized device names, e.g., ["cuda:0", "cuda:1"] or ["cpu"]
+    """
+
+    # === Step 1. Detect available device types ===
+    device_types = []
+    if torch.cuda.is_available():
+        device_types.append("cuda")
+    if hasattr(torch, "xpu") and torch.xpu.is_available():
+        device_types.append("xpu")
+    if hasattr(torch, "hpu") and is_hpex_available():
+        device_types.append("hpu")
+
+    # Always include CPU as a fallback
+    if not device_types:
+        device_types = ["cpu"]
+
+    # === Step 2. Parse different input formats ===
+    if device_map is None:
+        # Automatically detect one available device
+        if "cuda" in device_types:
+            return ["cuda:0"]
+        elif "xpu" in device_types:
+            return ["xpu:0"]
+        elif "hpu" in device_types:
+            return ["hpu:0"]
+        else:
+            return ["cpu"]
+
+    if isinstance(device_map, torch.device):
+        # Handle torch.device objects
+        dev_type = device_map.type
+        index = device_map.index
+        if dev_type == "cpu":
+            return ["cpu"]
+        if index is None:
+            index = 0
+        return [f"{dev_type}:{index}"]
+
+    if isinstance(device_map, int):
+        # Integer input → use primary available device type
+        device_type = device_types[0]
+        return [f"{device_type}:{device_map}"] if device_type != "cpu" else ["cpu"]
+
+    if isinstance(device_map, str):
+        # Remove whitespace
+        device_map = device_map.strip()
+        if device_map.lower() == "cpu":
+            return ["cpu"]
+
+        # Split by commas
+        parts = [x.strip() for x in device_map.split(",") if x.strip()]
+        parsed = []
+        for p in parts:
+            if p.isdigit():
+                # Numeric → assign to first available device type
+                device_type = device_types[0]
+                parsed.append(f"{device_type}:{p}" if device_type != "cpu" else "cpu")
+            else:
+                parsed.append(p)
+        return parsed
+
+    if isinstance(device_map, dict):
+        # Extract all devices recursively from dict values
+        devices = set()
+        for v in device_map.values():
+            devices.update(parse_all_available_device(v))
+        return sorted(devices)
+
+    raise TypeError(f"Unsupported device_map type: {type(device_map)}")
+
+
+# Important Notice This dispatch does not follow dict device_map, just extract all available devices and use them
+def dispatch_model_by_all_available_devices(model: torch.nn.Module,
+                                            device_map: Union[str, int, dict, None]) -> torch.nn.Module:
+    if device_map is None:
+        device_map = 0
+
+    no_split_modules = getattr(model, "_no_split_modules", [])
+    if device_map == "auto":
+        max_memory = get_balanced_memory(
+            model,
+            max_memory=None,
+            no_split_module_classes=no_split_modules,
+        )
+        device_map = infer_auto_device_map(
+            model,
+            max_memory=max_memory,
+            no_split_module_classes=no_split_modules
+        )
+        model = dispatch_model(model, device_map=device_map)
+        return model
+
+    devices = parse_all_available_device(device_map)
+
+    if len(devices) == 1:
+        model.to(devices[0])
+        return model
+
+    max_memory = get_balanced_memory(
+        model,
+        max_memory=None,
+        no_split_module_classes=no_split_modules,
+    )
+
+    # Filter max_memory with devices
+    #  assume only one GPU model
+    new_max_memory = {}
+    for device in devices:
+        if ":" in device:
+            device = int(device.split(":")[-1])
+        elif device == "cpu":
+            device = "cpu"
+        else:
+            raise ValueError(f"Unsupported device {device} in device_map: {device_map}")
+        new_max_memory[device] = max_memory[device]
+
+    device_map = infer_auto_device_map(
+        model,
+        max_memory=max_memory,
+        no_split_module_classes=no_split_modules
+    )
+    model = dispatch_model(model, device_map=device_map)
+    return model
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index f624ba54c..d3207c2bf 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -346,7 +346,7 @@ def __init__(
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
             gen_scheme = GenScheme(
-                scheme, self.model, quant_layer_names, fixed_layer_scheme_new, dataset, tokenizer=self.tokenizer
+                scheme, self.model, quant_layer_names, fixed_layer_scheme_new, dataset, device_map=device_map,tokenizer=self.tokenizer
             )
             self.layer_config = gen_scheme.get_layer_config()
 
@@ -1581,9 +1581,7 @@ def _quantize_via_rtn_blockwise(self, all_to_quantized_module_names: list[str])
                 if self.device_map is not None:
                     accelerate.hooks.remove_hook_from_submodules(block)
 
-                if (
-                    is_nv_fp(self.act_data_type) and any("nv_fp" in format_ for format_ in self.formats)
-                ) or is_static_wfp8afp8(self):
+                if (is_nv_fp(self.act_data_type) ) or is_static_wfp8afp8(self):
                     # enable moe experts act_max automatic generation for Linear
                     set_amax_for_all_moe_layers(block, attr_name="act_max")
                 # Normalize imatrix and quantize layers
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 0b61cb9dc..7130fc054 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -30,6 +30,7 @@
 import cpuinfo
 import torch
 import transformers
+from accelerate.utils import get_balanced_memory
 from packaging import version
 from torch.amp import autocast
 
@@ -3018,7 +3019,7 @@ def check_diffusers_installed():  # pragma: no cover
         exit(-1)
 
 
-def is_diffusion_model(model_or_path: Union[str, object]):
+def is_diffusion_model(model_or_path: Union[str, object]) -> bool:
     if isinstance(model_or_path, str):
         index_file = None
         if not os.path.isdir(model_or_path):
@@ -3041,3 +3042,6 @@ def is_diffusion_model(model_or_path: Union[str, object]):
         return isinstance(model_or_path, pipeline_utils.DiffusionPipeline)
     else:
         return False
+
+
+
diff --git a/auto_round/wrapper.py b/auto_round/wrapper.py
index f6bffa94d..0a90c3965 100644
--- a/auto_round/wrapper.py
+++ b/auto_round/wrapper.py
@@ -150,7 +150,7 @@ def _init_tuning_params_and_quant_func(self):
             )
             self._init_params("act_max_scale", p_dtype, (1), 1.0, not orig_layer.act_dynamic)
 
-        ## bias tuning
+        # Bias tuning
         if self.enable_norm_bias_tuning:
             self._init_params("bias_v", p_dtype, self.orig_layer.bias.shape, 0, True)
             from auto_round.data_type.int import quant_tensor_asym_wo_round
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index d171a667f..f8c36476f 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -25,89 +25,115 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    # @multi_card
-    # def test_multi_card(self):
-    #     model_name = "/models/Qwen3-8B"
-    #     target_bits = 4.644
-    #     scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4", "W8A16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
-    #     model, layer_config = ar.quantize()
-    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits+1e-3
-
-    def test_min_target_bits(self):
-        model_name = "/models/opt-125m"
-        target_bits = 4.644
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
-        model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-        avg_bits, _ = compute_avg_bits_for_model(model)
-        print(avg_bits)
-        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-
-    def test_max_target_bits(self):
-        model_name = "/models/opt-125m"
-        target_bits = 8.211
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
-        model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-        avg_bits, _ = compute_avg_bits_for_model(model)
-        print(avg_bits)
-        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    @multi_card
+    def test_multi_card(self):
+        model_name = "/models/Qwen3-8B"
+        target_bits = 5.254
+        for device_map in ["auto","0,1","0",None]:
+            scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4"))
+            ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, device_map=device_map)
+            model, layer_config = ar.quantize()
+            avg_bits, _ = compute_avg_bits_for_model(model)
+            print(avg_bits)
+            assert target_bits - 0.1 < avg_bits <= target_bits+1e-3
 
-    def test_patch_scheme(self):
-        model_name = "/models/opt-125m"
-        target_bits = 5
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, group_size=32)
-        model, layer_config = ar.quantize()
-        for n, m in model.named_modules():
-            if hasattr(m, "group_size"):
-                self.assertEqual(m.group_size, 32)
-        avg_bits, _ = compute_avg_bits_for_model(model)
-        print(avg_bits)
-        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    @multi_card
+    def test_dict_device_map(self):
+        model_name = "/models/Qwen3-8B"
+        target_bits = 8.755
+        device_map = {"up_proj":0,"down_proj":1}
 
-    def test_layer_config(self):
-        target_bits = 3.0
-        model_name = "/models/opt-125m"
-        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, layer_config=user_layer_config)
+        # scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
+        ar = AutoRound(model=model_name, scheme="W4A16", iters=0, nsamples=1, device_map=device_map)
         model, layer_config = ar.quantize()
-        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
-        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
-        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["group_size"], 32)
-        layer = get_module(model, "model.decoder.layers.10.fc1")
-        self.assertEqual(layer.bits, 8)
-        self.assertEqual(layer.sym, False)
-        self.assertEqual(layer.group_size, 32)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-    def test_lm_head_and_mix_dtype(self):
+    @multi_card
+    def test_dict_device_map(self): # TODO rtn mode has bug
         model_name = "/models/Qwen3-8B"
-        target_bits = 6
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
+        target_bits = 8.755
+        device_map = {"up_proj":0,"down_proj":1}
+
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1, device_map=device_map)
         model, layer_config = ar.quantize()
-        self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-    def test_auto_scheme_export(self):
-        model_name = "/models/opt-125m"
-        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-        ar = AutoRound(model=model_name, scheme=scheme)
-        ar.quantize_and_save(self.save_dir)
-        model_args = f"pretrained={self.save_dir}"
-        result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
-        print(result["results"]["lambada_openai"]["acc,none"])
-        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
-        shutil.rmtree(self.save_dir, ignore_errors=True)
+    # def test_min_target_bits(self):
+    #     model_name = "/models/opt-125m"
+    #     target_bits = 4.644
+    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+    #     model, layer_config = ar.quantize()
+    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    #
+    # def test_max_target_bits(self):
+    #     model_name = "/models/opt-125m"
+    #     target_bits = 8.211
+    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+    #     model, layer_config = ar.quantize()
+    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    #
+    # def test_patch_scheme(self):
+    #     model_name = "/models/opt-125m"
+    #     target_bits = 5
+    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, group_size=32)
+    #     model, layer_config = ar.quantize()
+    #     for n, m in model.named_modules():
+    #         if hasattr(m, "group_size"):
+    #             self.assertEqual(m.group_size, 32)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    #
+    # def test_layer_config(self):
+    #     target_bits = 3.0
+    #     model_name = "/models/opt-125m"
+    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+    #     user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, layer_config=user_layer_config)
+    #     model, layer_config = ar.quantize()
+    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
+    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
+    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["group_size"], 32)
+    #     layer = get_module(model, "model.decoder.layers.10.fc1")
+    #     self.assertEqual(layer.bits, 8)
+    #     self.assertEqual(layer.sym, False)
+    #     self.assertEqual(layer.group_size, 32)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    #
+    # def test_lm_head_and_mix_dtype(self):
+    #     model_name = "/models/Qwen3-8B"
+    #     target_bits = 6
+    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
+    #     model, layer_config = ar.quantize()
+    #     self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+    #     avg_bits, _ = compute_avg_bits_for_model(model)
+    #     print(avg_bits)
+    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+    #
+    # def test_auto_scheme_export(self):
+    #     model_name = "/models/opt-125m"
+    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+    #     ar = AutoRound(model=model_name, scheme=scheme)
+    #     ar.quantize_and_save(self.save_dir)
+    #     model_args = f"pretrained={self.save_dir}"
+    #     result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
+    #     print(result["results"]["lambada_openai"]["acc,none"])
+    #     self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+    #     shutil.rmtree(self.save_dir, ignore_errors=True)

From ab81181c97a4840801b6ebaef5fc7cc6cc2c8342 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 13 Oct 2025 09:25:17 +0000
Subject: [PATCH 58/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_auto_scheme.py | 11 ++++--
 auto_round/auto_schemes/utils.py           | 43 +++++++++-------------
 auto_round/compressors/base.py             | 10 ++++-
 auto_round/utils.py                        |  3 --
 test/test_cuda/test_auto_scheme.py         | 10 ++---
 5 files changed, 39 insertions(+), 38 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index c5e92ef4c..12e956eba 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -32,7 +32,7 @@ def __init__(
         quant_layer_names: Iterable[str],
         fixed_layer_scheme: dict[str, dict],
         dataset: str = "pile-10k",  # TODO use auto-round dataset
-        device_map:Union[str,  torch.device, int, dict, None] = None,
+        device_map: Union[str, torch.device, int, dict, None] = None,
         tokenizer=None,
     ):
         self.auto_scheme = auto_scheme
@@ -72,8 +72,13 @@ def get_layer_config(self):
         method_name = self.auto_scheme.method
         method_func = AUTO_SCHEMES_METHODS[method_name]
         layer_config = method_func(
-            self.auto_scheme, self.model, self.quant_layer_names, self.fixed_layer_scheme,
-            self.dataset, self.tokenizer,device_map=self.device_map,
+            self.auto_scheme,
+            self.model,
+            self.quant_layer_names,
+            self.fixed_layer_scheme,
+            self.dataset,
+            self.tokenizer,
+            device_map=self.device_map,
         )
         return layer_config
 
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 7e44eceb6..82bdcb99d 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -15,7 +15,7 @@
 from typing import Iterable, Union
 
 import torch
-from accelerate import infer_auto_device_map, dispatch_model
+from accelerate import dispatch_model, infer_auto_device_map
 from accelerate.utils import get_balanced_memory
 
 from auto_round.low_cpu_mem import get_module
@@ -24,10 +24,10 @@
 
 
 def apply_quant_scheme(
-        model: torch.nn.Module,
-        quant_layer_names: Iterable[str],
-        fixed_layer_scheme: dict[str, dict],
-        scheme: Union[str, dict],  # TODO add scale_dtype
+    model: torch.nn.Module,
+    quant_layer_names: Iterable[str],
+    fixed_layer_scheme: dict[str, dict],
+    scheme: Union[str, dict],  # TODO add scale_dtype
 ) -> None:
     """Apply a quantization scheme to each quantized layer.
 
@@ -48,7 +48,7 @@ def apply_quant_scheme(
 
 
 def remove_quant_scheme(
-        model: torch.nn.Module,
+    model: torch.nn.Module,
 ) -> None:
     """Remove attributes corresponding to the applied quantization scheme.
 
@@ -63,11 +63,11 @@ def remove_quant_scheme(
 
 
 def compute_avg_bits_for_scheme(
-        model: torch.nn.Module,
-        quant_layer_names: Iterable[str],
-        fixed_layer_scheme: dict[str, dict],
-        scheme: Union[str, dict, None] = None,
-        ignore_scale_zp_bits: bool = False,
+    model: torch.nn.Module,
+    quant_layer_names: Iterable[str],
+    fixed_layer_scheme: dict[str, dict],
+    scheme: Union[str, dict, None] = None,
+    ignore_scale_zp_bits: bool = False,
 ) -> tuple[float, float]:
     """Compute the average and total bit usage for the given quantization scheme.
 
@@ -133,8 +133,8 @@ def compute_avg_bits_for_model(model: torch.nn.Module, ignore_scale_zp_bits: boo
 
 
 def compute_layer_bits(
-        layer: torch.nn.Module,
-        ignore_scale_zp_bits: bool = False,
+    layer: torch.nn.Module,
+    ignore_scale_zp_bits: bool = False,
 ) -> tuple[int, float]:
     """Compute total and average bitwidth for a single quantized layer.
 
@@ -273,8 +273,9 @@ def parse_all_available_device(device_map: Union[str, torch.device, int, dict, N
 
 
 # Important Notice This dispatch does not follow dict device_map, just extract all available devices and use them
-def dispatch_model_by_all_available_devices(model: torch.nn.Module,
-                                            device_map: Union[str, int, dict, None]) -> torch.nn.Module:
+def dispatch_model_by_all_available_devices(
+    model: torch.nn.Module, device_map: Union[str, int, dict, None]
+) -> torch.nn.Module:
     if device_map is None:
         device_map = 0
 
@@ -285,11 +286,7 @@ def dispatch_model_by_all_available_devices(model: torch.nn.Module,
             max_memory=None,
             no_split_module_classes=no_split_modules,
         )
-        device_map = infer_auto_device_map(
-            model,
-            max_memory=max_memory,
-            no_split_module_classes=no_split_modules
-        )
+        device_map = infer_auto_device_map(model, max_memory=max_memory, no_split_module_classes=no_split_modules)
         model = dispatch_model(model, device_map=device_map)
         return model
 
@@ -317,10 +314,6 @@ def dispatch_model_by_all_available_devices(model: torch.nn.Module,
             raise ValueError(f"Unsupported device {device} in device_map: {device_map}")
         new_max_memory[device] = max_memory[device]
 
-    device_map = infer_auto_device_map(
-        model,
-        max_memory=max_memory,
-        no_split_module_classes=no_split_modules
-    )
+    device_map = infer_auto_device_map(model, max_memory=max_memory, no_split_module_classes=no_split_modules)
     model = dispatch_model(model, device_map=device_map)
     return model
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index d3207c2bf..db7e7a190 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -346,7 +346,13 @@ def __init__(
             from auto_round.auto_schemes.gen_auto_scheme import GenScheme
 
             gen_scheme = GenScheme(
-                scheme, self.model, quant_layer_names, fixed_layer_scheme_new, dataset, device_map=device_map,tokenizer=self.tokenizer
+                scheme,
+                self.model,
+                quant_layer_names,
+                fixed_layer_scheme_new,
+                dataset,
+                device_map=device_map,
+                tokenizer=self.tokenizer,
             )
             self.layer_config = gen_scheme.get_layer_config()
 
@@ -1581,7 +1587,7 @@ def _quantize_via_rtn_blockwise(self, all_to_quantized_module_names: list[str])
                 if self.device_map is not None:
                     accelerate.hooks.remove_hook_from_submodules(block)
 
-                if (is_nv_fp(self.act_data_type) ) or is_static_wfp8afp8(self):
+                if (is_nv_fp(self.act_data_type)) or is_static_wfp8afp8(self):
                     # enable moe experts act_max automatic generation for Linear
                     set_amax_for_all_moe_layers(block, attr_name="act_max")
                 # Normalize imatrix and quantize layers
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 7130fc054..51defb832 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -3042,6 +3042,3 @@ def is_diffusion_model(model_or_path: Union[str, object]) -> bool:
         return isinstance(model_or_path, pipeline_utils.DiffusionPipeline)
     else:
         return False
-
-
-
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index f8c36476f..525a8d508 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -29,19 +29,19 @@ def tearDownClass(self):
     def test_multi_card(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 5.254
-        for device_map in ["auto","0,1","0",None]:
+        for device_map in ["auto", "0,1", "0", None]:
             scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4"))
             ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, device_map=device_map)
             model, layer_config = ar.quantize()
             avg_bits, _ = compute_avg_bits_for_model(model)
             print(avg_bits)
-            assert target_bits - 0.1 < avg_bits <= target_bits+1e-3
+            assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     @multi_card
     def test_dict_device_map(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 8.755
-        device_map = {"up_proj":0,"down_proj":1}
+        device_map = {"up_proj": 0, "down_proj": 1}
 
         # scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
         ar = AutoRound(model=model_name, scheme="W4A16", iters=0, nsamples=1, device_map=device_map)
@@ -51,10 +51,10 @@ def test_dict_device_map(self):
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     @multi_card
-    def test_dict_device_map(self): # TODO rtn mode has bug
+    def test_dict_device_map(self):  # TODO rtn mode has bug
         model_name = "/models/Qwen3-8B"
         target_bits = 8.755
-        device_map = {"up_proj":0,"down_proj":1}
+        device_map = {"up_proj": 0, "down_proj": 1}
 
         scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1, device_map=device_map)

From 48e4feb995ba410874df6d9da1a296e0b2f1f2f6 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Mon, 13 Oct 2025 17:32:20 +0800
Subject: [PATCH 59/88] update ut

---
 test/test_cuda/test_auto_scheme.py | 157 ++++++++++++++---------------
 1 file changed, 73 insertions(+), 84 deletions(-)

diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 525a8d508..7397f7312 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -37,103 +37,92 @@ def test_multi_card(self):
             print(avg_bits)
             assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
+
+
     @multi_card
-    def test_dict_device_map(self):
+    def test_dict_device_map(self):  # TODO rtn mode has bug
         model_name = "/models/Qwen3-8B"
         target_bits = 8.755
         device_map = {"up_proj": 0, "down_proj": 1}
 
-        # scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
-        ar = AutoRound(model=model_name, scheme="W4A16", iters=0, nsamples=1, device_map=device_map)
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1, device_map=device_map)
         model, layer_config = ar.quantize()
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-    @multi_card
-    def test_dict_device_map(self):  # TODO rtn mode has bug
-        model_name = "/models/Qwen3-8B"
-        target_bits = 8.755
-        device_map = {"up_proj": 0, "down_proj": 1}
+    def test_min_target_bits(self):
+        model_name = "/models/opt-125m"
+        target_bits = 4.644
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1, device_map=device_map)
+    def test_max_target_bits(self):
+        model_name = "/models/opt-125m"
+        target_bits = 8.211
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_patch_scheme(self):
+        model_name = "/models/opt-125m"
+        target_bits = 5
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, group_size=32)
+        model, layer_config = ar.quantize()
+        for n, m in model.named_modules():
+            if hasattr(m, "group_size"):
+                self.assertEqual(m.group_size, 32)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_layer_config(self):
+        target_bits = 3.0
+        model_name = "/models/opt-125m"
+        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+        user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, layer_config=user_layer_config)
+        model, layer_config = ar.quantize()
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
+        self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["group_size"], 32)
+        layer = get_module(model, "model.decoder.layers.10.fc1")
+        self.assertEqual(layer.bits, 8)
+        self.assertEqual(layer.sym, False)
+        self.assertEqual(layer.group_size, 32)
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+    def test_lm_head_and_mix_dtype(self):
+        model_name = "/models/Qwen3-8B"
+        target_bits = 6
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
         model, layer_config = ar.quantize()
+        self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-    # def test_min_target_bits(self):
-    #     model_name = "/models/opt-125m"
-    #     target_bits = 4.644
-    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
-    #     model, layer_config = ar.quantize()
-    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-    #
-    # def test_max_target_bits(self):
-    #     model_name = "/models/opt-125m"
-    #     target_bits = 8.211
-    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
-    #     model, layer_config = ar.quantize()
-    #     # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-    #
-    # def test_patch_scheme(self):
-    #     model_name = "/models/opt-125m"
-    #     target_bits = 5
-    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, group_size=32)
-    #     model, layer_config = ar.quantize()
-    #     for n, m in model.named_modules():
-    #         if hasattr(m, "group_size"):
-    #             self.assertEqual(m.group_size, 32)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-    #
-    # def test_layer_config(self):
-    #     target_bits = 3.0
-    #     model_name = "/models/opt-125m"
-    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-    #     user_layer_config = {"model.decoder.layers.10.fc1": {"bits": 8, "group_size": 32, "sym": False}}
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, layer_config=user_layer_config)
-    #     model, layer_config = ar.quantize()
-    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["bits"], 8)
-    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["sym"], False)
-    #     self.assertEqual(layer_config["model.decoder.layers.10.fc1"]["group_size"], 32)
-    #     layer = get_module(model, "model.decoder.layers.10.fc1")
-    #     self.assertEqual(layer.bits, 8)
-    #     self.assertEqual(layer.sym, False)
-    #     self.assertEqual(layer.group_size, 32)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-    #
-    # def test_lm_head_and_mix_dtype(self):
-    #     model_name = "/models/Qwen3-8B"
-    #     target_bits = 6
-    #     scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
-    #     model, layer_config = ar.quantize()
-    #     self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
-    #     avg_bits, _ = compute_avg_bits_for_model(model)
-    #     print(avg_bits)
-    #     assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-    #
-    # def test_auto_scheme_export(self):
-    #     model_name = "/models/opt-125m"
-    #     scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
-    #     ar = AutoRound(model=model_name, scheme=scheme)
-    #     ar.quantize_and_save(self.save_dir)
-    #     model_args = f"pretrained={self.save_dir}"
-    #     result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
-    #     print(result["results"]["lambada_openai"]["acc,none"])
-    #     self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
-    #     shutil.rmtree(self.save_dir, ignore_errors=True)
+    def test_auto_scheme_export(self):
+        model_name = "/models/opt-125m"
+        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+        ar = AutoRound(model=model_name, scheme=scheme)
+        ar.quantize_and_save(self.save_dir)
+        model_args = f"pretrained={self.save_dir}"
+        result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
+        print(result["results"]["lambada_openai"]["acc,none"])
+        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+        shutil.rmtree(self.save_dir, ignore_errors=True)

From da7eac140dca0bc2875c2199e328046c87a664cc Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 13 Oct 2025 09:32:57 +0000
Subject: [PATCH 60/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 test/test_cuda/test_auto_scheme.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 7397f7312..b1b5b923c 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -37,8 +37,6 @@ def test_multi_card(self):
             print(avg_bits)
             assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-
-
     @multi_card
     def test_dict_device_map(self):  # TODO rtn mode has bug
         model_name = "/models/Qwen3-8B"

From 2b9c5bbacf4b1ab0f84ae41a28b0fb9b664fd25e Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 11:28:47 +0800
Subject: [PATCH 61/88] support large models

---
 auto_round/compressors/base.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index db7e7a190..6c243aa61 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -26,6 +26,7 @@
 import accelerate
 import torch
 from accelerate.big_modeling import dispatch_model, infer_auto_device_map
+from accelerate.utils import get_balanced_memory
 from torch import autocast
 from tqdm import tqdm
 from transformers import set_seed
@@ -2075,8 +2076,12 @@ def try_cache_inter_data_gpucpu(self, block_names, nsamples, layer_names=None, l
                         if str(self.model.device) == "cpu" and (
                             self.device.startswith("xpu") or self.device.startswith("cuda")
                         ):
-                            max_memory = get_max_vram()  # TODO model is not evenly split
                             no_split_modules = getattr(self.model, "_no_split_modules", [])
+                            max_memory = get_balanced_memory(
+                                self.model,
+                                max_memory=None,
+                                no_split_module_classes=no_split_modules,
+                            )
                             device_map = infer_auto_device_map(
                                 self.model, max_memory=max_memory, no_split_module_classes=no_split_modules
                             )

From fcfb9c6a2268d2dd5cb61e2b91bad31d9d5ee506 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 14:32:35 +0800
Subject: [PATCH 62/88] support shared layers

---
 auto_round/auto_schemes/utils.py   | 118 ++++++++++++++++++++++++++++-
 auto_round/schemes.py              |   2 +-
 test/test_cuda/test_auto_scheme.py |  34 ++++++++-
 3 files changed, 150 insertions(+), 4 deletions(-)

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 82bdcb99d..2b5ceb188 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -20,8 +20,12 @@
 
 from auto_round.low_cpu_mem import get_module
 from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
-from auto_round.utils import check_to_quantized, get_layer_features, is_hpex_available
+from auto_round.utils import check_to_quantized, get_layer_features, is_hpex_available, get_block_names, \
+    SUPPORTED_LAYER_TYPES
 
+import re
+import torch
+from typing import Union, Iterable
 
 def apply_quant_scheme(
     model: torch.nn.Module,
@@ -317,3 +321,115 @@ def dispatch_model_by_all_available_devices(
     device_map = infer_auto_device_map(model, max_memory=max_memory, no_split_module_classes=no_split_modules)
     model = dispatch_model(model, device_map=device_map)
     return model
+
+
+def merge_lists_unionfind(list_of_lists):
+    parent = {}
+
+    def find(x):
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    def union(x, y):
+        root_x, root_y = find(x), find(y)
+        if root_x != root_y:
+            parent[root_y] = root_x
+
+    # 初始化并查集
+    for lst in list_of_lists:
+        for item in lst:
+            if item not in parent:
+                parent[item] = item
+        for i in range(1, len(lst)):
+            union(lst[0], lst[i])
+
+    # 收集结果
+    groups = {}
+    for item in parent:
+        root = find(item)
+        groups.setdefault(root, []).append(item)
+    return list(groups.values())
+
+def parse_shared_layers(
+    model: torch.nn.Module,
+    shared_patterns: Iterable[Iterable[str]]
+) -> list[list[str]]:
+    """
+    Parse shared layer groups based on regex or substring matches.
+
+    Args:
+        model (torch.nn.Module): The model whose modules will be analyzed.
+        shared_patterns (Iterable[Iterable[str]]):
+            Each inner iterable defines one shared group. Each element can be:
+              - a string: checked by full-name or substring match
+              - a regex pattern: checked by re.fullmatch or re.search
+
+    Returns:
+        list[list[str]]: A list of matched shared layer groups.
+    """
+    if not shared_patterns:
+        return []
+    # Retrieve all high-level block names (for example, transformer blocks)
+    for n,m in model.named_modules():
+        m.tmp_name = n # attach global name
+
+    block_names = get_block_names(model, quant_vision=True)
+    block_names = [item for sublist in block_names for item in sublist]
+
+    # Collect all supported layer names from the model
+    supported_layer_names = [
+        name for name, module in model.named_modules()
+        if type(module) in SUPPORTED_LAYER_TYPES
+    ]
+
+    # Separate groups into those already fully matched and those requiring pattern matching
+    direct_match_groups = []
+    fuzzy_match_groups = []
+    for group in shared_patterns:
+        match_status = {name: (name in supported_layer_names) for name in group}
+        if all(match_status.values()):
+            direct_match_groups.append(list(match_status.keys()))
+        else:
+            fuzzy_match_groups.append(match_status)
+
+    matched_groups = list(direct_match_groups)
+
+    # Search each block for modules matching remaining patterns
+    for block_name in block_names:
+        block_module = get_module(model,block_name)
+        block_layer_local_names = [
+            name for name, module in block_module.named_modules()
+            if type(module) in SUPPORTED_LAYER_TYPES
+        ]
+        block_layer_names = []
+        for name in block_layer_local_names:
+            module = get_module(block_module,name)
+            block_layer_names.append(module.tmp_name)
+
+
+        for group in fuzzy_match_groups:
+            matched_layers = set()
+            for pattern, is_direct in group.items():
+                if is_direct:
+                    matched_layers.add(pattern)
+                    continue
+
+                for layer_name in block_layer_names:
+                    # Try regex match first
+                    try:
+                        if re.fullmatch(pattern, layer_name) or re.search(pattern, layer_name):
+                            matched_layers.add(layer_name)
+                            continue
+                    except re.error:
+                        pass  # Not a valid regex, fallback to substring matching
+
+                    # Substring or partial match
+                    if pattern in layer_name:
+                        matched_layers.add(layer_name)
+
+            if matched_layers:
+                matched_groups.append(sorted(matched_layers))
+    matched_groups = merge_lists_unionfind(matched_groups)
+    return matched_groups
\ No newline at end of file
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index fa4cbe025..471517931 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -266,7 +266,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 @dataclass
 class AutoScheme:
     avg_bits: float
-    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str]]]
+    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str],...]]
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
     ignore_scale_zp_bits: bool = False
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index b1b5b923c..2cb6cfa13 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,7 +3,6 @@
 import shutil
 import sys
 import unittest
-
 from auto_round.testing_utils import multi_card
 
 sys.path.insert(0, "../..")
@@ -25,6 +24,37 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
+    def test_shared_layers(self):
+        model_name = "/models/opt-125m"
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        shared_layers = [["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
+                        ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"), ("fc1", "fc2")]
+        from auto_round.auto_schemes.utils import parse_shared_layers
+        res = parse_shared_layers(model, shared_layers)
+        self.assertEqual(len(res), 24)
+        assert ['model.decoder.layers.2.self_attn.out_proj', 'model.decoder.layers.2.self_attn.q_proj',
+                'model.decoder.layers.2.self_attn.v_proj'] in res
+        assert ['model.decoder.layers.6.fc1', 'model.decoder.layers.6.fc2'] in res
+        assert ['model.decoder.layers.7.fc1', 'model.decoder.layers.7.fc2'] in res
+        target_bits=5.0
+        scheme = AutoScheme(avg_bits=target_bits, options=("W4A16","MXFP8"),shared_layers=shared_layers)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        for names in res:
+            bits=[]
+            for name in names:
+                module = get_module(model, name)
+                if hasattr(module,"orig_layer"):
+                    bits.append(module.orig_layer.bits)
+                else:
+                    bits.append(module.bits)
+            bits=set(bits)
+            self.assertEqual(len(bits), 1)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
     @multi_card
     def test_multi_card(self):
         model_name = "/models/Qwen3-8B"
@@ -44,7 +74,7 @@ def test_dict_device_map(self):  # TODO rtn mode has bug
         device_map = {"up_proj": 0, "down_proj": 1}
 
         scheme = AutoScheme(avg_bits=target_bits, options=("MXFP8"))
-        ar = AutoRound(model=model_name, scheme=scheme, iters=1, nsamples=1, device_map=device_map)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, device_map=device_map)
         model, layer_config = ar.quantize()
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)

From 91ec73da984fb4f12a08d5973556f8223e1a5e81 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 14 Oct 2025 06:36:26 +0000
Subject: [PATCH 63/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/utils.py   | 38 +++++++++++++-----------------
 auto_round/schemes.py              |  2 +-
 test/test_cuda/test_auto_scheme.py | 31 +++++++++++++++---------
 3 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 2b5ceb188..2c435d31e 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -11,6 +11,7 @@
 # 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 re
 from dataclasses import asdict, fields
 from typing import Iterable, Union
 
@@ -20,12 +21,14 @@
 
 from auto_round.low_cpu_mem import get_module
 from auto_round.schemes import QuantizationScheme, preset_name_to_scheme
-from auto_round.utils import check_to_quantized, get_layer_features, is_hpex_available, get_block_names, \
-    SUPPORTED_LAYER_TYPES
+from auto_round.utils import (
+    SUPPORTED_LAYER_TYPES,
+    check_to_quantized,
+    get_block_names,
+    get_layer_features,
+    is_hpex_available,
+)
 
-import re
-import torch
-from typing import Union, Iterable
 
 def apply_quant_scheme(
     model: torch.nn.Module,
@@ -352,10 +355,8 @@ def union(x, y):
         groups.setdefault(root, []).append(item)
     return list(groups.values())
 
-def parse_shared_layers(
-    model: torch.nn.Module,
-    shared_patterns: Iterable[Iterable[str]]
-) -> list[list[str]]:
+
+def parse_shared_layers(model: torch.nn.Module, shared_patterns: Iterable[Iterable[str]]) -> list[list[str]]:
     """
     Parse shared layer groups based on regex or substring matches.
 
@@ -372,17 +373,14 @@ def parse_shared_layers(
     if not shared_patterns:
         return []
     # Retrieve all high-level block names (for example, transformer blocks)
-    for n,m in model.named_modules():
-        m.tmp_name = n # attach global name
+    for n, m in model.named_modules():
+        m.tmp_name = n  # attach global name
 
     block_names = get_block_names(model, quant_vision=True)
     block_names = [item for sublist in block_names for item in sublist]
 
     # Collect all supported layer names from the model
-    supported_layer_names = [
-        name for name, module in model.named_modules()
-        if type(module) in SUPPORTED_LAYER_TYPES
-    ]
+    supported_layer_names = [name for name, module in model.named_modules() if type(module) in SUPPORTED_LAYER_TYPES]
 
     # Separate groups into those already fully matched and those requiring pattern matching
     direct_match_groups = []
@@ -398,17 +396,15 @@ def parse_shared_layers(
 
     # Search each block for modules matching remaining patterns
     for block_name in block_names:
-        block_module = get_module(model,block_name)
+        block_module = get_module(model, block_name)
         block_layer_local_names = [
-            name for name, module in block_module.named_modules()
-            if type(module) in SUPPORTED_LAYER_TYPES
+            name for name, module in block_module.named_modules() if type(module) in SUPPORTED_LAYER_TYPES
         ]
         block_layer_names = []
         for name in block_layer_local_names:
-            module = get_module(block_module,name)
+            module = get_module(block_module, name)
             block_layer_names.append(module.tmp_name)
 
-
         for group in fuzzy_match_groups:
             matched_layers = set()
             for pattern, is_direct in group.items():
@@ -432,4 +428,4 @@ def parse_shared_layers(
             if matched_layers:
                 matched_groups.append(sorted(matched_layers))
     matched_groups = merge_lists_unionfind(matched_groups)
-    return matched_groups
\ No newline at end of file
+    return matched_groups
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 471517931..789cbe1cb 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -266,7 +266,7 @@ def get_gguf_scheme(scheme: Union[str, QuantizationScheme]) -> str:
 @dataclass
 class AutoScheme:
     avg_bits: float
-    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str],...]]
+    options: Union[str, list[Union[QuantizationScheme, str]], tuple[Union[QuantizationScheme, str], ...]]
     shared_layers: Optional[Iterable[Iterable[str]]] = None
     method: str = "default"
     ignore_scale_zp_bits: bool = False
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 2cb6cfa13..451867a1e 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,6 +3,7 @@
 import shutil
 import sys
 import unittest
+
 from auto_round.testing_utils import multi_card
 
 sys.path.insert(0, "../..")
@@ -27,30 +28,38 @@ def tearDownClass(self):
     def test_shared_layers(self):
         model_name = "/models/opt-125m"
         from transformers import AutoModelForCausalLM, AutoTokenizer
+
         model = AutoModelForCausalLM.from_pretrained(model_name)
-        shared_layers = [["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
-                        ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"), ("fc1", "fc2")]
+        shared_layers = [
+            ["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
+            ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"),
+            ("fc1", "fc2"),
+        ]
         from auto_round.auto_schemes.utils import parse_shared_layers
+
         res = parse_shared_layers(model, shared_layers)
         self.assertEqual(len(res), 24)
-        assert ['model.decoder.layers.2.self_attn.out_proj', 'model.decoder.layers.2.self_attn.q_proj',
-                'model.decoder.layers.2.self_attn.v_proj'] in res
-        assert ['model.decoder.layers.6.fc1', 'model.decoder.layers.6.fc2'] in res
-        assert ['model.decoder.layers.7.fc1', 'model.decoder.layers.7.fc2'] in res
-        target_bits=5.0
-        scheme = AutoScheme(avg_bits=target_bits, options=("W4A16","MXFP8"),shared_layers=shared_layers)
+        assert [
+            "model.decoder.layers.2.self_attn.out_proj",
+            "model.decoder.layers.2.self_attn.q_proj",
+            "model.decoder.layers.2.self_attn.v_proj",
+        ] in res
+        assert ["model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"] in res
+        assert ["model.decoder.layers.7.fc1", "model.decoder.layers.7.fc2"] in res
+        target_bits = 5.0
+        scheme = AutoScheme(avg_bits=target_bits, options=("W4A16", "MXFP8"), shared_layers=shared_layers)
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
         model, layer_config = ar.quantize()
         avg_bits, _ = compute_avg_bits_for_model(model)
         for names in res:
-            bits=[]
+            bits = []
             for name in names:
                 module = get_module(model, name)
-                if hasattr(module,"orig_layer"):
+                if hasattr(module, "orig_layer"):
                     bits.append(module.orig_layer.bits)
                 else:
                     bits.append(module.bits)
-            bits=set(bits)
+            bits = set(bits)
             self.assertEqual(len(bits), 1)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3

From 9a2738ace6dacf2a4f1e1b05a3422c0f08b1d782 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 15:16:40 +0800
Subject: [PATCH 64/88] update a little

---
 auto_round/compressors/base.py | 36 ++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index b003ec6cc..d5110348c 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -320,8 +320,40 @@ def __init__(
 
         if isinstance(scheme, AutoScheme):
             if self.mllm:
-                logger.info("AutoScheme with MLLM is not supported yet.")
-                sys.exit(1)
+                logger.info("AutoScheme is not yet supported for multimodal LLMs.")
+                sys.exit(-1)
+
+            if getattr(model, "is_fp8", False):
+                logger.info("AutoScheme does not currently support FP8 models.")
+                sys.exit(-1)
+
+            all_dtypes = []
+            for option in scheme.options:
+                # Skip pure BF16 option
+                if option == "BF16":
+                    continue
+
+                # Resolve the quantization scheme or data type
+                dtype = "int"
+                if isinstance(option, str):
+                    option = preset_name_to_scheme(option)
+
+                if isinstance(option, QuantizationScheme):
+                    dtype = option.data_type
+                elif isinstance(option, dict):
+                    dtype = option.get("data_type", "int")
+
+                all_dtypes.append(dtype)
+
+            # Check for mixed data types
+            unique_dtypes = set(all_dtypes)
+            if len(unique_dtypes) > 1:
+                logger.warning(
+                    "Models with mixed data_types "
+                    "cannot yet be exported to real formats except GGUF. "
+                    "Please save the model using the `fake` format for now."
+                )
+
             layer_config, self.has_qlayer_outside_block = set_layer_config(
                 self.model,
                 self.layer_config,

From 6132faa6938457998ba7fe864b48bab81c59954e Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 15:54:45 +0800
Subject: [PATCH 65/88] fix gguf issue

---
 auto_round/utils.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/auto_round/utils.py b/auto_round/utils.py
index 51defb832..37460f119 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2997,7 +2997,10 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
     for emd_name in embedding_layer_names:
         if emd_name in layer_config:
             continue
-        cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
+        if not tie_word_embeddings:
+            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["embedding"]]
+        else:
+            cfg = GGUF_INNER_CONFIG[GGUF_CONFIG[gguf_name.lower()]["lm_head"]]
         cfg = {**cfg, "fixed_by_user": False, "scale_dtype": default_scale_dtype}
         layer_config[emd_name] = cfg
 

From c111608403f370220aa75fbf9969dd30cdef33d6 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 17:41:02 +0800
Subject: [PATCH 66/88] support gguf

---
 auto_round/auto_schemes/utils.py   |  13 +-
 test/test_cpu/test_gguf_format.py  | 485 ++++++++++++++---------------
 test/test_cuda/test_auto_scheme.py |  20 ++
 3 files changed, 271 insertions(+), 247 deletions(-)

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index 2c435d31e..d75959ce6 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -98,6 +98,8 @@ def compute_avg_bits_for_scheme(
 
     for name in quant_layer_names:
         module = get_module(model, name)
+        # if isinstance(module,torch.nn.Embedding):
+        #     continue
         if not hasattr(module, "weight"):
             continue
         total_params += module.weight.numel()
@@ -130,6 +132,8 @@ def compute_avg_bits_for_model(model: torch.nn.Module, ignore_scale_zp_bits: boo
             continue
         if not hasattr(module, "weight"):
             continue
+        # if isinstance(module,torch.nn.Embedding): # Tricky setting for Embedding
+        #     continue
         total_params += module.weight.numel()
         layer_bits, _ = compute_layer_bits(module, ignore_scale_zp_bits)
         total_quantized_bits += layer_bits
@@ -161,9 +165,11 @@ def compute_layer_bits(
 
     # Unquantized layer or ignoring scale/zp overhead
     if weight_bits >= 16 or ignore_scale_zp_bits:
-        if super_weight_bits is not None:  # reset gguf 16 bits to 32 bits, TODO gguf q4_0, q4_1 may have bug
-            return 32 * n_param, 32
-        return weight_bits * n_param, 16.0
+        if super_weight_bits is not None:  # reset gguf 16 bits to 32 bits, TODO gguf q4_0, q4_1 have bug (wenhua)
+            if weight_bits >= 16:
+                return 32 * n_param, 32
+
+        return weight_bits * n_param, weight_bits if weight_bits<16 else 16
 
     in_features, out_features = get_layer_features(layer)
 
@@ -192,7 +198,6 @@ def compute_layer_bits(
     avg_bits = total_bits / n_param
     return total_bits, avg_bits
 
-
 def parse_all_available_device(device_map: Union[str, torch.device, int, dict, None] = None) -> list:
     """
     Parse the device map and return a list of all available devices.
diff --git a/test/test_cpu/test_gguf_format.py b/test/test_cpu/test_gguf_format.py
index 96b489ffe..44453af4c 100644
--- a/test/test_cpu/test_gguf_format.py
+++ b/test/test_cpu/test_gguf_format.py
@@ -23,10 +23,10 @@ def __iter__(self):
 class TestGGUF(unittest.TestCase):
     @classmethod
     def setUpClass(self):
-        self.model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-0.5B-Instruct"
-        self.model_name = "Qwen/Qwen2.5-0.5B-Instruct"
-        self.model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+        # self.model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-0.5B-Instruct"
+        # self.model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+        # self.model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
+        # self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
         self.llm_dataloader = LLMDataLoader()
 
     @classmethod
@@ -34,60 +34,40 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    def test_basic_usage(self):
-        python_path = sys.executable
-        res = os.system(
-            f"cd ../.. && {python_path} -m auto_round --model /tf_dataset/auto_round/models/benzart/gemma-2b-it-fine-tuning-for-code-test "
-            f" --bs 16 --iters 0 --nsamples 1 --format gguf:q4_k_m"
-        )
-        if res > 0 or res == -1:
-            assert False, "cmd line test fail, please have a check"
-        shutil.rmtree("./saved", ignore_errors=True)
-
-        res = os.system(
-            f"cd ../.. && {python_path} -m auto_round --model {self.model_name}"
-            f" --bs 16 --iters 1 --nsamples 1 --format fake,gguf:q4_0"
-        )
-        if res > 0 or res == -1:
-            assert False, "cmd line test fail, please have a check"
-        shutil.rmtree("./saved", ignore_errors=True)
-
-    def test_q4_0(self):
-        bits, group_size, sym = 4, 32, True
-        autoround = AutoRound(
-            self.model,
-            self.tokenizer,
-            bits=bits,
-            group_size=group_size,
-            sym=sym,
-            iters=1,
-            data_type="int",
-            nsamples=1,
-            seqlen=8,
-        )
-        quantized_model_path = "./saved"
-
-        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_0")
-        gguf_file = os.listdir(quantized_model_path)[0]
-        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-        text = "There is a girl who likes adventure,"
-        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-
-        # from auto_round.eval.evaluation import simple_evaluate_user_model
-        # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
-        # # 0.246
-        # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.23)
-        shutil.rmtree("./saved", ignore_errors=True)
-
-    # def test_q4_1(self):
-    #     bits, group_size, sym = 4, 32, False
+    # def test_basic_usage(self):
+    #     python_path = sys.executable
+    #     res = os.system(
+    #         f"cd ../.. && {python_path} -m auto_round --model /tf_dataset/auto_round/models/benzart/gemma-2b-it-fine-tuning-for-code-test "
+    #         f" --bs 16 --iters 0 --nsamples 1 --format gguf:q4_k_m"
+    #     )
+    #     if res > 0 or res == -1:
+    #         assert False, "cmd line test fail, please have a check"
+    #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    #     res = os.system(
+    #         f"cd ../.. && {python_path} -m auto_round --model {self.model_name}"
+    #         f" --bs 16 --iters 1 --nsamples 1 --format fake,gguf:q4_0"
+    #     )
+    #     if res > 0 or res == -1:
+    #         assert False, "cmd line test fail, please have a check"
+    #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # def test_q4_0(self):
+    #     bits, group_size, sym = 4, 32, True
     #     autoround = AutoRound(
-    #         self.model, self.tokenizer, bits=bits, group_size=group_size, sym=sym, iters=1, data_type="int", nsamples=1
+    #         self.model,
+    #         self.tokenizer,
+    #         bits=bits,
+    #         group_size=group_size,
+    #         sym=sym,
+    #         iters=1,
+    #         data_type="int",
+    #         nsamples=1,
+    #         seqlen=8,
     #     )
     #     quantized_model_path = "./saved"
     #
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_1")
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_0")
     #     gguf_file = os.listdir(quantized_model_path)[0]
     #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
     #     text = "There is a girl who likes adventure,"
@@ -96,223 +76,243 @@ def test_q4_0(self):
     #
     #     # from auto_round.eval.evaluation import simple_evaluate_user_model
     #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
-    #     # # 0.23
-    #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.22)
+    #     # # 0.246
+    #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.23)
     #     shutil.rmtree("./saved", ignore_errors=True)
-
-    def test_func(self):
-        bits, group_size, sym = 4, 128, True
-        autoround = AutoRound(
-            self.model,
-            self.tokenizer,
-            # bits=bits,
-            # group_size=group_size,
-            # sym=sym,
-            iters=1,
-            nsamples=1,
-            seqlen=10,
-            # data_type="int"
-        )
-        quantized_model_path = "./saved"
-        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_1")
-        self.assertTrue(autoround.group_size == 32)
-        self.assertFalse(autoround.sym)
-        gguf_file = os.listdir("saved")[0]
-        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-        text = "There is a girl who likes adventure,"
-        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-        shutil.rmtree("./saved", ignore_errors=True)
-
-        # model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-        # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-        # autoround = AutoRound(
-        #     model,
-        #     self.tokenizer,
-        #     bits=3,
-        #     group_size=16,
-        #     sym=True,
-        #     iters=1,
-        #     nsamples=1,
-        #     data_type="int_sym_dq",
-        #     super_group_size=16,
-        #     super_bits=6,
-        # )
-        quantized_model_path = "./saved"
-        # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
-        # from auto_round.eval.evaluation import simple_evaluate_user_model
-        # gguf_file = os.listdir("saved")[0]
-        # model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-        # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="lambada_openai", eval_model_dtype="bf16")
-        # self.assertGreater(result['results']['lambada_openai']['acc,none'], 0.5)
-        shutil.rmtree("./saved", ignore_errors=True)
-
     #
-    # def test_q5_k(self):
-    #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    # # def test_q4_1(self):
+    # #     bits, group_size, sym = 4, 32, False
+    # #     autoround = AutoRound(
+    # #         self.model, self.tokenizer, bits=bits, group_size=group_size, sym=sym, iters=1, data_type="int", nsamples=1
+    # #     )
+    # #     quantized_model_path = "./saved"
+    # #
+    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_1")
+    # #     gguf_file = os.listdir(quantized_model_path)[0]
+    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+    # #     text = "There is a girl who likes adventure,"
+    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+    # #
+    # #     # from auto_round.eval.evaluation import simple_evaluate_user_model
+    # #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
+    # #     # # 0.23
+    # #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.22)
+    # #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # def test_func(self):
+    #     bits, group_size, sym = 4, 128, True
     #     autoround = AutoRound(
-    #         model,
+    #         self.model,
     #         self.tokenizer,
-    #         bits=5,
-    #         group_size=32,
-    #         sym=False,
+    #         # bits=bits,
+    #         # group_size=group_size,
+    #         # sym=sym,
     #         iters=1,
     #         nsamples=1,
-    #         data_type="int_asym_dq",
-    #         super_group_size=8,
-    #         super_bits=6,
+    #         seqlen=10,
+    #         # data_type="int"
     #     )
     #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_1")
+    #     self.assertTrue(autoround.group_size == 32)
+    #     self.assertFalse(autoround.sym)
     #     gguf_file = os.listdir("saved")[0]
     #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
     #     text = "There is a girl who likes adventure,"
     #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
     #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
     #     shutil.rmtree("./saved", ignore_errors=True)
-
-    # def test_q6_k(self):
-    #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+    #
+    #     # model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+    #     # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    #     # autoround = AutoRound(
+    #     #     model,
+    #     #     self.tokenizer,
+    #     #     bits=3,
+    #     #     group_size=16,
+    #     #     sym=True,
+    #     #     iters=1,
+    #     #     nsamples=1,
+    #     #     data_type="int_sym_dq",
+    #     #     super_group_size=16,
+    #     #     super_bits=6,
+    #     # )
+    #     quantized_model_path = "./saved"
+    #     # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
+    #     # from auto_round.eval.evaluation import simple_evaluate_user_model
+    #     # gguf_file = os.listdir("saved")[0]
+    #     # model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+    #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="lambada_openai", eval_model_dtype="bf16")
+    #     # self.assertGreater(result['results']['lambada_openai']['acc,none'], 0.5)
+    #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # #
+    # # def test_q5_k(self):
+    # #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+    # #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    # #     autoround = AutoRound(
+    # #         model,
+    # #         self.tokenizer,
+    # #         bits=5,
+    # #         group_size=32,
+    # #         sym=False,
+    # #         iters=1,
+    # #         nsamples=1,
+    # #         data_type="int_asym_dq",
+    # #         super_group_size=8,
+    # #         super_bits=6,
+    # #     )
+    # #     quantized_model_path = "./saved"
+    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
+    # #     gguf_file = os.listdir("saved")[0]
+    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+    # #     text = "There is a girl who likes adventure,"
+    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+    # #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # # def test_q6_k(self):
+    # #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+    # #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    # #     autoround = AutoRound(
+    # #         model,
+    # #         self.tokenizer,
+    # #         bits=6,
+    # #         group_size=16,
+    # #         sym=True,
+    # #         iters=1,
+    # #         nsamples=1,
+    # #         data_type="int_sym_dq",
+    # #         super_group_size=16,
+    # #         super_bits=8,
+    # #     )
+    # #     quantized_model_path = "./saved"
+    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k")
+    # #     gguf_file = os.listdir("saved")[0]
+    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+    # #     text = "There is a girl who likes adventure,"
+    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+    # #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # def test_gguf_baseline(self):
+    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
     #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
     #     autoround = AutoRound(
     #         model,
     #         self.tokenizer,
-    #         bits=6,
+    #         bits=3,
     #         group_size=16,
     #         sym=True,
-    #         iters=1,
-    #         nsamples=1,
-    #         data_type="int_sym_dq",
+    #         iters=0,
+    #         nsamples=8,
+    #         seqlen=2,
+    #         data_type="rtn_int_sym_dq",
     #         super_group_size=16,
-    #         super_bits=8,
+    #         super_bits=6,
+    #         disable_opt_rtn=True,
     #     )
     #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k")
-    #     gguf_file = os.listdir("saved")[0]
-    #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="fake")
+    #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")
     #     text = "There is a girl who likes adventure,"
     #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
     #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
     #     shutil.rmtree("./saved", ignore_errors=True)
-
-    def test_gguf_baseline(self):
-        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
-        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-        autoround = AutoRound(
-            model,
-            self.tokenizer,
-            bits=3,
-            group_size=16,
-            sym=True,
-            iters=0,
-            nsamples=8,
-            seqlen=2,
-            data_type="rtn_int_sym_dq",
-            super_group_size=16,
-            super_bits=6,
-            disable_opt_rtn=True,
-        )
-        quantized_model_path = "./saved"
-        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="fake")
-        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")
-        text = "There is a girl who likes adventure,"
-        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-        shutil.rmtree("./saved", ignore_errors=True)
-        #
-        # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-        # autoround = AutoRound(
-        #     model,
-        #     self.tokenizer,
-        #     bits=5,
-        #     group_size=32,
-        #     sym=True,
-        #     iters=0,
-        #     nsamples=8,
-        #     data_type="int_asym_dq",
-        #     super_group_size=8,
-        #     super_bits=6,
-        #     disable_opt_rtn=True,
-        # )
-        # quantized_model_path = "./saved"
-        # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q5_k_s,fake")
-        # model = AutoModelForCausalLM.from_pretrained(quantized_model_path + "/fake", device_map="auto")
-        # text = "There is a girl who likes adventure,"
-        # inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-        # print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-        # shutil.rmtree("./saved", ignore_errors=True)
-
-    def test_q4_k_m(self):
-        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
-        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-        layer_config = {
-            "lm_head": {
-                "bits": 4,
-                "group_size": 32,
-                "sym": False,
-                "data_type": "int_asym_dq",
-                "super_bits": 6,
-                "super_group_size": 8,
-            },
-            "model.embed_tokens": {"bits": 6, "group_size": 32, "super_bits": 6, "super_group_size": 8},
-            "model.layers.12.mlp.gate_proj": {"bits": 3},
-            "model.layers.10.mlp.gate_proj": {"bits": 8},
-        }
-        autoround = AutoRound(
-            model,
-            tokenizer,
-            layer_config=layer_config,
-            iters=0,
-            seqlen=1,
-            nsamples=8,
-            dataset=self.llm_dataloader,
-            disable_opt_rtn=True,
-        )
-        quantized_model_path = "./saved"
-        autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
-        self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["super_group_size"], 16)
-        self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["data_type"], "int_sym_dq")
-        self.assertEqual(autoround.layer_config["model.layers.7.self_attn.v_proj"]["data_type"], "int_asym_dq")
-        self.assertEqual(autoround.model.model.layers[0].self_attn.v_proj.bits, 6)
-        self.assertEqual(autoround.model.model.layers[12].self_attn.v_proj.bits, 4)
-        self.assertEqual(autoround.model.model.embed_tokens.bits, 6)
-        self.assertEqual(autoround.model.model.embed_tokens.group_size, 16)
-        self.assertEqual(autoround.model.model.layers[12].mlp.gate_proj.bits, 3)
-        self.assertEqual(autoround.model.model.layers[10].mlp.gate_proj.bits, 8)
-        self.assertEqual(autoround.layer_config["model.layers.10.mlp.gate_proj"]["mostly"], "gguf:q8_0")
-        shutil.rmtree("./saved", ignore_errors=True)
-
-        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-        autoround = AutoRound(model, tokenizer, iters=0, nsamples=1, seqlen=128, disable_opt_rtn=False)
-        quantized_model_path = "./saved"
-        autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
-        shutil.rmtree("./saved", ignore_errors=True)
-
-    def test_all_format(self):
-        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
-        python_path = sys.executable
-        # for gguf_format in ["gguf:q4_0", "gguf:q4_1", "gguf:q4_k_m", "gguf:q6_k"]:
-        for gguf_format in ["gguf:q4_k_m"]:
-            res = os.system(
-                f"cd ../.. && {python_path} -m auto_round --model {model_name} "
-                f" --bs 16 --iters 1 --nsamples 1 --seqlen 16 --format {gguf_format}"
-            )
-            if res > 0 or res == -1:
-                assert False, "cmd line test fail, please have a check"
-            shutil.rmtree("../../tmp_autoround", ignore_errors=True)
-
-            res = os.system(
-                f"cd ../.. && {python_path} -m auto_round --model {model_name}"
-                f" --bs 16 --iters 0 --nsamples 1 --seqlen 16 --format fake,{gguf_format}"
-            )
-            if res > 0 or res == -1:
-                assert False, "cmd line test fail, please have a check"
-            shutil.rmtree("../../tmp_autoround", ignore_errors=True)
+    #     #
+    #     # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    #     # autoround = AutoRound(
+    #     #     model,
+    #     #     self.tokenizer,
+    #     #     bits=5,
+    #     #     group_size=32,
+    #     #     sym=True,
+    #     #     iters=0,
+    #     #     nsamples=8,
+    #     #     data_type="int_asym_dq",
+    #     #     super_group_size=8,
+    #     #     super_bits=6,
+    #     #     disable_opt_rtn=True,
+    #     # )
+    #     # quantized_model_path = "./saved"
+    #     # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q5_k_s,fake")
+    #     # model = AutoModelForCausalLM.from_pretrained(quantized_model_path + "/fake", device_map="auto")
+    #     # text = "There is a girl who likes adventure,"
+    #     # inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+    #     # print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+    #     # shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # def test_q4_k_m(self):
+    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    #     tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    #     layer_config = {
+    #         "lm_head": {
+    #             "bits": 4,
+    #             "group_size": 32,
+    #             "sym": False,
+    #             "data_type": "int_asym_dq",
+    #             "super_bits": 6,
+    #             "super_group_size": 8,
+    #         },
+    #         "model.embed_tokens": {"bits": 6, "group_size": 32, "super_bits": 6, "super_group_size": 8},
+    #         "model.layers.12.mlp.gate_proj": {"bits": 3},
+    #         "model.layers.10.mlp.gate_proj": {"bits": 8},
+    #     }
+    #     autoround = AutoRound(
+    #         model,
+    #         tokenizer,
+    #         layer_config=layer_config,
+    #         iters=0,
+    #         seqlen=1,
+    #         nsamples=8,
+    #         dataset=self.llm_dataloader,
+    #         disable_opt_rtn=True,
+    #     )
+    #     quantized_model_path = "./saved"
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
+    #     self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["super_group_size"], 16)
+    #     self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["data_type"], "int_sym_dq")
+    #     self.assertEqual(autoround.layer_config["model.layers.7.self_attn.v_proj"]["data_type"], "int_asym_dq")
+    #     self.assertEqual(autoround.model.model.layers[0].self_attn.v_proj.bits, 6)
+    #     self.assertEqual(autoround.model.model.layers[12].self_attn.v_proj.bits, 4)
+    #     self.assertEqual(autoround.model.model.embed_tokens.bits, 6)
+    #     self.assertEqual(autoround.model.model.embed_tokens.group_size, 16)
+    #     self.assertEqual(autoround.model.model.layers[12].mlp.gate_proj.bits, 3)
+    #     self.assertEqual(autoround.model.model.layers[10].mlp.gate_proj.bits, 8)
+    #     self.assertEqual(autoround.layer_config["model.layers.10.mlp.gate_proj"]["mostly"], "gguf:q8_0")
+    #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+    #     autoround = AutoRound(model, tokenizer, iters=0, nsamples=1, seqlen=128, disable_opt_rtn=False)
+    #     quantized_model_path = "./saved"
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
+    #     shutil.rmtree("./saved", ignore_errors=True)
+    #
+    # def test_all_format(self):
+    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+    #     python_path = sys.executable
+    #     # for gguf_format in ["gguf:q4_0", "gguf:q4_1", "gguf:q4_k_m", "gguf:q6_k"]:
+    #     for gguf_format in ["gguf:q4_k_m"]:
+    #         res = os.system(
+    #             f"cd ../.. && {python_path} -m auto_round --model {model_name} "
+    #             f" --bs 16 --iters 1 --nsamples 1 --seqlen 16 --format {gguf_format}"
+    #         )
+    #         if res > 0 or res == -1:
+    #             assert False, "cmd line test fail, please have a check"
+    #         shutil.rmtree("../../tmp_autoround", ignore_errors=True)
+    #
+    #         res = os.system(
+    #             f"cd ../.. && {python_path} -m auto_round --model {model_name}"
+    #             f" --bs 16 --iters 0 --nsamples 1 --seqlen 16 --format fake,{gguf_format}"
+    #         )
+    #         if res > 0 or res == -1:
+    #             assert False, "cmd line test fail, please have a check"
+    #         shutil.rmtree("../../tmp_autoround", ignore_errors=True)
 
     def test_vlm_gguf(self):
-        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2-VL-2B-Instruct"
+        model_name = "/models/Qwen2-VL-2B-Instruct"
         from auto_round import AutoRoundMLLM
         from auto_round.utils import mllm_load_model
 
@@ -329,7 +329,6 @@ def test_vlm_gguf(self):
         autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_0")
         self.assertTrue("mmproj-model.gguf" in os.listdir("./saved"))
         for file_name in os.listdir(quantized_model_path):
-            file_name = os.listdir(quantized_model_path)[0]
             file_size = os.path.getsize(os.path.join(quantized_model_path, file_name)) / 1024**2
             if file_name == "mmproj-model.gguf":
                 self.assertAlmostEqual(file_size, 2535, delta=1.0)
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 451867a1e..e19a43e95 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -25,6 +25,26 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
+    def test_gguf_export(self):
+        model_name = "/models/Qwen3-0.6B"
+        target_bits = 3
+        scheme = AutoScheme(avg_bits=target_bits, options=("GGUF:Q2_K_S", "GGUF:Q4_K_M"), ignore_scale_zp_bits=True)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0)
+        ar.quantize_and_save(self.save_dir, format="gguf:q2_k_s")
+        shutil.rmtree("./saved", ignore_errors=True)
+
+    def test_gguf(self):
+        model_name = "/models/Qwen3-8B"
+        target_bits = 3
+        scheme = AutoScheme(avg_bits=target_bits, options=("GGUF:Q2_K_S", "GGUF:Q4_K_M"), ignore_scale_zp_bits=True)
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, disable_opt_rtn=True)
+        model, layer_config = ar.quantize()
+        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
+        avg_bits, _ = compute_avg_bits_for_model(model, ignore_scale_zp_bits=True)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
+
     def test_shared_layers(self):
         model_name = "/models/opt-125m"
         from transformers import AutoModelForCausalLM, AutoTokenizer

From c74df50851f518de322bfc8e1f3192990e55eb2a Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 14 Oct 2025 09:41:59 +0000
Subject: [PATCH 67/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/utils.py   | 3 ++-
 test/test_cuda/test_auto_scheme.py | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_schemes/utils.py
index d75959ce6..73191c40f 100644
--- a/auto_round/auto_schemes/utils.py
+++ b/auto_round/auto_schemes/utils.py
@@ -169,7 +169,7 @@ def compute_layer_bits(
             if weight_bits >= 16:
                 return 32 * n_param, 32
 
-        return weight_bits * n_param, weight_bits if weight_bits<16 else 16
+        return weight_bits * n_param, min(16, weight_bits)
 
     in_features, out_features = get_layer_features(layer)
 
@@ -198,6 +198,7 @@ def compute_layer_bits(
     avg_bits = total_bits / n_param
     return total_bits, avg_bits
 
+
 def parse_all_available_device(device_map: Union[str, torch.device, int, dict, None] = None) -> list:
     """
     Parse the device map and return a list of all available devices.
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index e19a43e95..e11ce1a01 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -44,7 +44,6 @@ def test_gguf(self):
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
-
     def test_shared_layers(self):
         model_name = "/models/opt-125m"
         from transformers import AutoModelForCausalLM, AutoTokenizer

From ae87b77872faba7859f375d86d32a430964b0445 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Tue, 14 Oct 2025 17:54:18 +0800
Subject: [PATCH 68/88] revert test

---
 test/test_cpu/test_gguf_format.py | 484 +++++++++++++++---------------
 1 file changed, 242 insertions(+), 242 deletions(-)

diff --git a/test/test_cpu/test_gguf_format.py b/test/test_cpu/test_gguf_format.py
index 44453af4c..d71920b39 100644
--- a/test/test_cpu/test_gguf_format.py
+++ b/test/test_cpu/test_gguf_format.py
@@ -23,10 +23,10 @@ def __iter__(self):
 class TestGGUF(unittest.TestCase):
     @classmethod
     def setUpClass(self):
-        # self.model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-0.5B-Instruct"
-        # self.model_name = "Qwen/Qwen2.5-0.5B-Instruct"
-        # self.model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
-        # self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+        self.model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-0.5B-Instruct"
+        self.model_name = "Qwen/Qwen2.5-0.5B-Instruct"
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_name, torch_dtype="auto", trust_remote_code=True)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
         self.llm_dataloader = LLMDataLoader()
 
     @classmethod
@@ -34,40 +34,60 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-    # def test_basic_usage(self):
-    #     python_path = sys.executable
-    #     res = os.system(
-    #         f"cd ../.. && {python_path} -m auto_round --model /tf_dataset/auto_round/models/benzart/gemma-2b-it-fine-tuning-for-code-test "
-    #         f" --bs 16 --iters 0 --nsamples 1 --format gguf:q4_k_m"
-    #     )
-    #     if res > 0 or res == -1:
-    #         assert False, "cmd line test fail, please have a check"
-    #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    #     res = os.system(
-    #         f"cd ../.. && {python_path} -m auto_round --model {self.model_name}"
-    #         f" --bs 16 --iters 1 --nsamples 1 --format fake,gguf:q4_0"
-    #     )
-    #     if res > 0 or res == -1:
-    #         assert False, "cmd line test fail, please have a check"
-    #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # def test_q4_0(self):
-    #     bits, group_size, sym = 4, 32, True
+    def test_basic_usage(self):
+        python_path = sys.executable
+        res = os.system(
+            f"cd ../.. && {python_path} -m auto_round --model /tf_dataset/auto_round/models/benzart/gemma-2b-it-fine-tuning-for-code-test "
+            f" --bs 16 --iters 0 --nsamples 1 --format gguf:q4_k_m"
+        )
+        if res > 0 or res == -1:
+            assert False, "cmd line test fail, please have a check"
+        shutil.rmtree("./saved", ignore_errors=True)
+
+        res = os.system(
+            f"cd ../.. && {python_path} -m auto_round --model {self.model_name}"
+            f" --bs 16 --iters 1 --nsamples 1 --format fake,gguf:q4_0"
+        )
+        if res > 0 or res == -1:
+            assert False, "cmd line test fail, please have a check"
+        shutil.rmtree("./saved", ignore_errors=True)
+
+    def test_q4_0(self):
+        bits, group_size, sym = 4, 32, True
+        autoround = AutoRound(
+            self.model,
+            self.tokenizer,
+            bits=bits,
+            group_size=group_size,
+            sym=sym,
+            iters=1,
+            data_type="int",
+            nsamples=1,
+            seqlen=8,
+        )
+        quantized_model_path = "./saved"
+
+        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_0")
+        gguf_file = os.listdir(quantized_model_path)[0]
+        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+        text = "There is a girl who likes adventure,"
+        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+
+        # from auto_round.eval.evaluation import simple_evaluate_user_model
+        # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
+        # # 0.246
+        # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.23)
+        shutil.rmtree("./saved", ignore_errors=True)
+
+    # def test_q4_1(self):
+    #     bits, group_size, sym = 4, 32, False
     #     autoround = AutoRound(
-    #         self.model,
-    #         self.tokenizer,
-    #         bits=bits,
-    #         group_size=group_size,
-    #         sym=sym,
-    #         iters=1,
-    #         data_type="int",
-    #         nsamples=1,
-    #         seqlen=8,
+    #         self.model, self.tokenizer, bits=bits, group_size=group_size, sym=sym, iters=1, data_type="int", nsamples=1
     #     )
     #     quantized_model_path = "./saved"
     #
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_0")
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_1")
     #     gguf_file = os.listdir(quantized_model_path)[0]
     #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
     #     text = "There is a girl who likes adventure,"
@@ -76,243 +96,223 @@ def tearDownClass(self):
     #
     #     # from auto_round.eval.evaluation import simple_evaluate_user_model
     #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
-    #     # # 0.246
-    #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.23)
+    #     # # 0.23
+    #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.22)
     #     shutil.rmtree("./saved", ignore_errors=True)
+
+    def test_func(self):
+        bits, group_size, sym = 4, 128, True
+        autoround = AutoRound(
+            self.model,
+            self.tokenizer,
+            # bits=bits,
+            # group_size=group_size,
+            # sym=sym,
+            iters=1,
+            nsamples=1,
+            seqlen=10,
+            # data_type="int"
+        )
+        quantized_model_path = "./saved"
+        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_1")
+        self.assertTrue(autoround.group_size == 32)
+        self.assertFalse(autoround.sym)
+        gguf_file = os.listdir("saved")[0]
+        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+        text = "There is a girl who likes adventure,"
+        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+        shutil.rmtree("./saved", ignore_errors=True)
+
+        # model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+        # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+        # autoround = AutoRound(
+        #     model,
+        #     self.tokenizer,
+        #     bits=3,
+        #     group_size=16,
+        #     sym=True,
+        #     iters=1,
+        #     nsamples=1,
+        #     data_type="int_sym_dq",
+        #     super_group_size=16,
+        #     super_bits=6,
+        # )
+        quantized_model_path = "./saved"
+        # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
+        # from auto_round.eval.evaluation import simple_evaluate_user_model
+        # gguf_file = os.listdir("saved")[0]
+        # model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
+        # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="lambada_openai", eval_model_dtype="bf16")
+        # self.assertGreater(result['results']['lambada_openai']['acc,none'], 0.5)
+        shutil.rmtree("./saved", ignore_errors=True)
+
     #
-    # # def test_q4_1(self):
-    # #     bits, group_size, sym = 4, 32, False
-    # #     autoround = AutoRound(
-    # #         self.model, self.tokenizer, bits=bits, group_size=group_size, sym=sym, iters=1, data_type="int", nsamples=1
-    # #     )
-    # #     quantized_model_path = "./saved"
-    # #
-    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q4_1")
-    # #     gguf_file = os.listdir(quantized_model_path)[0]
-    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-    # #     text = "There is a girl who likes adventure,"
-    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-    # #
-    # #     # from auto_round.eval.evaluation import simple_evaluate_user_model
-    # #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="openbookqa", eval_model_dtype="bf16")
-    # #     # # 0.23
-    # #     # self.assertGreater(result['results']['openbookqa']['acc,none'], 0.22)
-    # #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # def test_func(self):
-    #     bits, group_size, sym = 4, 128, True
+    # def test_q5_k(self):
+    #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
     #     autoround = AutoRound(
-    #         self.model,
+    #         model,
     #         self.tokenizer,
-    #         # bits=bits,
-    #         # group_size=group_size,
-    #         # sym=sym,
+    #         bits=5,
+    #         group_size=32,
+    #         sym=False,
     #         iters=1,
     #         nsamples=1,
-    #         seqlen=10,
-    #         # data_type="int"
+    #         data_type="int_asym_dq",
+    #         super_group_size=8,
+    #         super_bits=6,
     #     )
     #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_1")
-    #     self.assertTrue(autoround.group_size == 32)
-    #     self.assertFalse(autoround.sym)
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
     #     gguf_file = os.listdir("saved")[0]
     #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
     #     text = "There is a girl who likes adventure,"
     #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
     #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
     #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    #     # model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-    #     # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    #     # autoround = AutoRound(
-    #     #     model,
-    #     #     self.tokenizer,
-    #     #     bits=3,
-    #     #     group_size=16,
-    #     #     sym=True,
-    #     #     iters=1,
-    #     #     nsamples=1,
-    #     #     data_type="int_sym_dq",
-    #     #     super_group_size=16,
-    #     #     super_bits=6,
-    #     # )
-    #     quantized_model_path = "./saved"
-    #     # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
-    #     # from auto_round.eval.evaluation import simple_evaluate_user_model
-    #     # gguf_file = os.listdir("saved")[0]
-    #     # model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-    #     # result = simple_evaluate_user_model(model, self.tokenizer, batch_size=16, tasks="lambada_openai", eval_model_dtype="bf16")
-    #     # self.assertGreater(result['results']['lambada_openai']['acc,none'], 0.5)
-    #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # #
-    # # def test_q5_k(self):
-    # #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-    # #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    # #     autoround = AutoRound(
-    # #         model,
-    # #         self.tokenizer,
-    # #         bits=5,
-    # #         group_size=32,
-    # #         sym=False,
-    # #         iters=1,
-    # #         nsamples=1,
-    # #         data_type="int_asym_dq",
-    # #         super_group_size=8,
-    # #         super_bits=6,
-    # #     )
-    # #     quantized_model_path = "./saved"
-    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k_s")
-    # #     gguf_file = os.listdir("saved")[0]
-    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-    # #     text = "There is a girl who likes adventure,"
-    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-    # #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # # def test_q6_k(self):
-    # #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
-    # #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    # #     autoround = AutoRound(
-    # #         model,
-    # #         self.tokenizer,
-    # #         bits=6,
-    # #         group_size=16,
-    # #         sym=True,
-    # #         iters=1,
-    # #         nsamples=1,
-    # #         data_type="int_sym_dq",
-    # #         super_group_size=16,
-    # #         super_bits=8,
-    # #     )
-    # #     quantized_model_path = "./saved"
-    # #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k")
-    # #     gguf_file = os.listdir("saved")[0]
-    # #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
-    # #     text = "There is a girl who likes adventure,"
-    # #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-    # #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-    # #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # def test_gguf_baseline(self):
-    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+
+    # def test_q6_k(self):
+    #     model_name = "Qwen/Qwen2.5-1.5B-Instruct"
     #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
     #     autoround = AutoRound(
     #         model,
     #         self.tokenizer,
-    #         bits=3,
+    #         bits=6,
     #         group_size=16,
     #         sym=True,
-    #         iters=0,
-    #         nsamples=8,
-    #         seqlen=2,
-    #         data_type="rtn_int_sym_dq",
+    #         iters=1,
+    #         nsamples=1,
+    #         data_type="int_sym_dq",
     #         super_group_size=16,
-    #         super_bits=6,
-    #         disable_opt_rtn=True,
+    #         super_bits=8,
     #     )
     #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="fake")
-    #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")
+    #     autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q*_k")
+    #     gguf_file = os.listdir("saved")[0]
+    #     model = AutoModelForCausalLM.from_pretrained(quantized_model_path, gguf_file=gguf_file, device_map="auto")
     #     text = "There is a girl who likes adventure,"
     #     inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
     #     print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
     #     shutil.rmtree("./saved", ignore_errors=True)
-    #     #
-    #     # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    #     # autoround = AutoRound(
-    #     #     model,
-    #     #     self.tokenizer,
-    #     #     bits=5,
-    #     #     group_size=32,
-    #     #     sym=True,
-    #     #     iters=0,
-    #     #     nsamples=8,
-    #     #     data_type="int_asym_dq",
-    #     #     super_group_size=8,
-    #     #     super_bits=6,
-    #     #     disable_opt_rtn=True,
-    #     # )
-    #     # quantized_model_path = "./saved"
-    #     # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q5_k_s,fake")
-    #     # model = AutoModelForCausalLM.from_pretrained(quantized_model_path + "/fake", device_map="auto")
-    #     # text = "There is a girl who likes adventure,"
-    #     # inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
-    #     # print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
-    #     # shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # def test_q4_k_m(self):
-    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
-    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    #     tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-    #     layer_config = {
-    #         "lm_head": {
-    #             "bits": 4,
-    #             "group_size": 32,
-    #             "sym": False,
-    #             "data_type": "int_asym_dq",
-    #             "super_bits": 6,
-    #             "super_group_size": 8,
-    #         },
-    #         "model.embed_tokens": {"bits": 6, "group_size": 32, "super_bits": 6, "super_group_size": 8},
-    #         "model.layers.12.mlp.gate_proj": {"bits": 3},
-    #         "model.layers.10.mlp.gate_proj": {"bits": 8},
-    #     }
-    #     autoround = AutoRound(
-    #         model,
-    #         tokenizer,
-    #         layer_config=layer_config,
-    #         iters=0,
-    #         seqlen=1,
-    #         nsamples=8,
-    #         dataset=self.llm_dataloader,
-    #         disable_opt_rtn=True,
-    #     )
-    #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
-    #     self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["super_group_size"], 16)
-    #     self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["data_type"], "int_sym_dq")
-    #     self.assertEqual(autoround.layer_config["model.layers.7.self_attn.v_proj"]["data_type"], "int_asym_dq")
-    #     self.assertEqual(autoround.model.model.layers[0].self_attn.v_proj.bits, 6)
-    #     self.assertEqual(autoround.model.model.layers[12].self_attn.v_proj.bits, 4)
-    #     self.assertEqual(autoround.model.model.embed_tokens.bits, 6)
-    #     self.assertEqual(autoround.model.model.embed_tokens.group_size, 16)
-    #     self.assertEqual(autoround.model.model.layers[12].mlp.gate_proj.bits, 3)
-    #     self.assertEqual(autoround.model.model.layers[10].mlp.gate_proj.bits, 8)
-    #     self.assertEqual(autoround.layer_config["model.layers.10.mlp.gate_proj"]["mostly"], "gguf:q8_0")
-    #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    #     model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
-    #     autoround = AutoRound(model, tokenizer, iters=0, nsamples=1, seqlen=128, disable_opt_rtn=False)
-    #     quantized_model_path = "./saved"
-    #     autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
-    #     shutil.rmtree("./saved", ignore_errors=True)
-    #
-    # def test_all_format(self):
-    #     model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
-    #     python_path = sys.executable
-    #     # for gguf_format in ["gguf:q4_0", "gguf:q4_1", "gguf:q4_k_m", "gguf:q6_k"]:
-    #     for gguf_format in ["gguf:q4_k_m"]:
-    #         res = os.system(
-    #             f"cd ../.. && {python_path} -m auto_round --model {model_name} "
-    #             f" --bs 16 --iters 1 --nsamples 1 --seqlen 16 --format {gguf_format}"
-    #         )
-    #         if res > 0 or res == -1:
-    #             assert False, "cmd line test fail, please have a check"
-    #         shutil.rmtree("../../tmp_autoround", ignore_errors=True)
-    #
-    #         res = os.system(
-    #             f"cd ../.. && {python_path} -m auto_round --model {model_name}"
-    #             f" --bs 16 --iters 0 --nsamples 1 --seqlen 16 --format fake,{gguf_format}"
-    #         )
-    #         if res > 0 or res == -1:
-    #             assert False, "cmd line test fail, please have a check"
-    #         shutil.rmtree("../../tmp_autoround", ignore_errors=True)
+
+    def test_gguf_baseline(self):
+        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+        autoround = AutoRound(
+            model,
+            self.tokenizer,
+            bits=3,
+            group_size=16,
+            sym=True,
+            iters=0,
+            nsamples=8,
+            seqlen=2,
+            data_type="rtn_int_sym_dq",
+            super_group_size=16,
+            super_bits=6,
+            disable_opt_rtn=True,
+        )
+        quantized_model_path = "./saved"
+        autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="fake")
+        model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")
+        text = "There is a girl who likes adventure,"
+        inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+        print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+        shutil.rmtree("./saved", ignore_errors=True)
+        #
+        # model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+        # autoround = AutoRound(
+        #     model,
+        #     self.tokenizer,
+        #     bits=5,
+        #     group_size=32,
+        #     sym=True,
+        #     iters=0,
+        #     nsamples=8,
+        #     data_type="int_asym_dq",
+        #     super_group_size=8,
+        #     super_bits=6,
+        #     disable_opt_rtn=True,
+        # )
+        # quantized_model_path = "./saved"
+        # autoround.quantize_and_save(output_dir=quantized_model_path, inplace=False, format="gguf:q5_k_s,fake")
+        # model = AutoModelForCausalLM.from_pretrained(quantized_model_path + "/fake", device_map="auto")
+        # text = "There is a girl who likes adventure,"
+        # inputs = self.tokenizer(text, return_tensors="pt").to(model.device)
+        # print(self.tokenizer.decode(model.generate(**inputs, max_new_tokens=10)[0]))
+        # shutil.rmtree("./saved", ignore_errors=True)
+
+    def test_q4_k_m(self):
+        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+        layer_config = {
+            "lm_head": {
+                "bits": 4,
+                "group_size": 32,
+                "sym": False,
+                "data_type": "int_asym_dq",
+                "super_bits": 6,
+                "super_group_size": 8,
+            },
+            "model.embed_tokens": {"bits": 6, "group_size": 32, "super_bits": 6, "super_group_size": 8},
+            "model.layers.12.mlp.gate_proj": {"bits": 3},
+            "model.layers.10.mlp.gate_proj": {"bits": 8},
+        }
+        autoround = AutoRound(
+            model,
+            tokenizer,
+            layer_config=layer_config,
+            iters=0,
+            seqlen=1,
+            nsamples=8,
+            dataset=self.llm_dataloader,
+            disable_opt_rtn=True,
+        )
+        quantized_model_path = "./saved"
+        autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
+        self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["super_group_size"], 16)
+        self.assertEqual(autoround.layer_config["model.layers.11.self_attn.v_proj"]["data_type"], "int_sym_dq")
+        self.assertEqual(autoround.layer_config["model.layers.7.self_attn.v_proj"]["data_type"], "int_asym_dq")
+        self.assertEqual(autoround.model.model.layers[0].self_attn.v_proj.bits, 6)
+        self.assertEqual(autoround.model.model.layers[12].self_attn.v_proj.bits, 4)
+        self.assertEqual(autoround.model.model.embed_tokens.bits, 6)
+        self.assertEqual(autoround.model.model.embed_tokens.group_size, 16)
+        self.assertEqual(autoround.model.model.layers[12].mlp.gate_proj.bits, 3)
+        self.assertEqual(autoround.model.model.layers[10].mlp.gate_proj.bits, 8)
+        self.assertEqual(autoround.layer_config["model.layers.10.mlp.gate_proj"]["mostly"], "gguf:q8_0")
+        shutil.rmtree("./saved", ignore_errors=True)
+
+        model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype="auto", trust_remote_code=True)
+        autoround = AutoRound(model, tokenizer, iters=0, nsamples=1, seqlen=128, disable_opt_rtn=False)
+        quantized_model_path = "./saved"
+        autoround.quantize_and_save(output_dir=quantized_model_path, format="gguf:q4_k_m,fake")
+        shutil.rmtree("./saved", ignore_errors=True)
+
+    def test_all_format(self):
+        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2.5-1.5B-Instruct"
+        python_path = sys.executable
+        # for gguf_format in ["gguf:q4_0", "gguf:q4_1", "gguf:q4_k_m", "gguf:q6_k"]:
+        for gguf_format in ["gguf:q4_k_m"]:
+            res = os.system(
+                f"cd ../.. && {python_path} -m auto_round --model {model_name} "
+                f" --bs 16 --iters 1 --nsamples 1 --seqlen 16 --format {gguf_format}"
+            )
+            if res > 0 or res == -1:
+                assert False, "cmd line test fail, please have a check"
+            shutil.rmtree("../../tmp_autoround", ignore_errors=True)
+
+            res = os.system(
+                f"cd ../.. && {python_path} -m auto_round --model {model_name}"
+                f" --bs 16 --iters 0 --nsamples 1 --seqlen 16 --format fake,{gguf_format}"
+            )
+            if res > 0 or res == -1:
+                assert False, "cmd line test fail, please have a check"
+            shutil.rmtree("../../tmp_autoround", ignore_errors=True)
 
     def test_vlm_gguf(self):
-        model_name = "/models/Qwen2-VL-2B-Instruct"
+        model_name = "/tf_dataset/auto_round/models/Qwen/Qwen2-VL-2B-Instruct"
         from auto_round import AutoRoundMLLM
         from auto_round.utils import mllm_load_model
 

From 26822471304592b17c96f8b67b0a206f9d3050ea Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Wed, 15 Oct 2025 15:26:25 +0800
Subject: [PATCH 69/88] update

---
 auto_round/auto_schemes/gen_auto_scheme.py | 47 +++++++++++++++++++++-
 auto_round/utils.py                        |  3 +-
 test/test_cuda/test_auto_scheme.py         | 22 +++++-----
 3 files changed, 58 insertions(+), 14 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index 12e956eba..cd735e60c 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -19,8 +19,10 @@
 from auto_round import AutoScheme
 from auto_round.auto_schemes import AUTO_SCHEMES_METHODS
 from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
+from auto_round.export.export_to_gguf.config import GGUF_INNER_CONFIG
 from auto_round.logger import logger
-
+from auto_round.utils import get_layer_features, get_module, _gguf_type_fallback
+import math
 
 class GenScheme:
     """Generate and validate quantization schemes for model layers."""
@@ -68,7 +70,7 @@ def _check_configs(self) -> None:
                 f"Target avg_bits={target:.3f} is outside the valid range " f"[{min_avg_bit:.3f}, {max_avg_bit:.3f}]."
             )
 
-    def get_layer_config(self):
+    def get_layer_config(self) -> dict[str, dict]:
         method_name = self.auto_scheme.method
         method_func = AUTO_SCHEMES_METHODS[method_name]
         layer_config = method_func(
@@ -80,6 +82,47 @@ def get_layer_config(self):
             self.tokenizer,
             device_map=self.device_map,
         )
+        layer_config = self.fallback_gguf_layer_config(layer_config)
+        return layer_config
+
+    def fallback_gguf_layer_config(self, layer_config: dict[str, dict]) -> dict[str, dict]:
+        """
+        Apply fallback configurations for GGUF quantized layers when the current
+        layer configuration is incompatible with input feature alignment.
+
+        Args:
+            layer_config (dict[str, dict]): Mapping from layer name to its quantization scheme.
+
+        Returns:
+            dict[str, dict]: Updated layer configuration with applied fallbacks if necessary.
+        """
+        for name, scheme in layer_config.items():  # TODO: add unit test (wenhua), the code is a little tricky
+            if scheme.get("super_bits") is None:
+                continue  # Skip non-GGUF k-quant layers
+
+            layer = get_module(self.model, name)
+            input_features = get_layer_features(layer)
+
+            # Determine fallback quantization type
+            if input_features % 256 != 0 and input_features % 32 != 0:
+                new_type = "gguf:bf16"
+            else:
+                bits = scheme["bits"]
+                new_type = f"gguf:q{bits}_0"
+
+                if new_type not in GGUF_INNER_CONFIG:
+                    new_type = f"gguf:q{bits}_1"
+
+                    if new_type not in GGUF_INNER_CONFIG:
+                        current_type = f"gguf:q{bits}_k"
+                        new_type = _gguf_type_fallback(current_type)
+
+            # Apply fallback configuration
+            target_config = GGUF_INNER_CONFIG[new_type]
+            scheme.update(target_config)
+
+            logger.warning(f"Fallback applied: {name} → {new_type}")
+
         return layer_config
 
     def compute_avg_bit_range(self) -> tuple[float, float]:
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 37460f119..0309fd9ef 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1879,7 +1879,8 @@ def _search_gguf_type(gguf_type):
     return None
 
 
-def _gguf_type_fallback(gguf_type):
+def _gguf_type_fallback(gguf_type:str)->str:
+    gguf_type = gguf_type.lower()
     if gguf_type in ("gguf:q2_k", "gguf:q3_k", "gguf:q4_k"):
         gguf_type = "gguf:q5_0"
     elif gguf_type == "gguf:q5_k":
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index e11ce1a01..7dc9f6f65 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -31,7 +31,7 @@ def test_gguf_export(self):
         scheme = AutoScheme(avg_bits=target_bits, options=("GGUF:Q2_K_S", "GGUF:Q4_K_M"), ignore_scale_zp_bits=True)
         ar = AutoRound(model=model_name, scheme=scheme, iters=0)
         ar.quantize_and_save(self.save_dir, format="gguf:q2_k_s")
-        shutil.rmtree("./saved", ignore_errors=True)
+        shutil.rmtree(self.save_dir, ignore_errors=True)
 
     def test_gguf(self):
         model_name = "/models/Qwen3-8B"
@@ -82,18 +82,18 @@ def test_shared_layers(self):
             self.assertEqual(len(bits), 1)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-
+    #
     @multi_card
     def test_multi_card(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 5.254
-        for device_map in ["auto", "0,1", "0", None]:
-            scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4"))
-            ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, device_map=device_map)
-            model, layer_config = ar.quantize()
-            avg_bits, _ = compute_avg_bits_for_model(model)
-            print(avg_bits)
-            assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+        # for device_map in ["auto", "0,1", "0", None]:
+        scheme = AutoScheme(avg_bits=target_bits, options=("NVFP4"))
+        ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+        model, layer_config = ar.quantize()
+        avg_bits, _ = compute_avg_bits_for_model(model)
+        print(avg_bits)
+        assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     @multi_card
     def test_dict_device_map(self):  # TODO rtn mode has bug
@@ -118,7 +118,7 @@ def test_min_target_bits(self):
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
-
+    #
     def test_max_target_bits(self):
         model_name = "/models/opt-125m"
         target_bits = 8.211
@@ -174,7 +174,7 @@ def test_lm_head_and_mix_dtype(self):
 
     def test_auto_scheme_export(self):
         model_name = "/models/opt-125m"
-        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "BF16"))
+        scheme = AutoScheme(avg_bits=3, options=("W2A16", "W4A16", "W8A16", "BF16"))
         ar = AutoRound(model=model_name, scheme=scheme)
         ar.quantize_and_save(self.save_dir)
         model_args = f"pretrained={self.save_dir}"

From 30fee225246a56b43b00834e9c834f8b61c366b6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 15 Oct 2025 07:27:10 +0000
Subject: [PATCH 70/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_schemes/gen_auto_scheme.py | 5 +++--
 auto_round/utils.py                        | 2 +-
 test/test_cuda/test_auto_scheme.py         | 2 ++
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_schemes/gen_auto_scheme.py
index cd735e60c..106e3d46d 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_schemes/gen_auto_scheme.py
@@ -11,6 +11,7 @@
 # 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 math
 from dataclasses import asdict
 from typing import Iterable, Union
 
@@ -21,8 +22,8 @@
 from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
 from auto_round.export.export_to_gguf.config import GGUF_INNER_CONFIG
 from auto_round.logger import logger
-from auto_round.utils import get_layer_features, get_module, _gguf_type_fallback
-import math
+from auto_round.utils import _gguf_type_fallback, get_layer_features, get_module
+
 
 class GenScheme:
     """Generate and validate quantization schemes for model layers."""
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 0309fd9ef..49354bd64 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1879,7 +1879,7 @@ def _search_gguf_type(gguf_type):
     return None
 
 
-def _gguf_type_fallback(gguf_type:str)->str:
+def _gguf_type_fallback(gguf_type: str) -> str:
     gguf_type = gguf_type.lower()
     if gguf_type in ("gguf:q2_k", "gguf:q3_k", "gguf:q4_k"):
         gguf_type = "gguf:q5_0"
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 7dc9f6f65..4b5155e6f 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -82,6 +82,7 @@ def test_shared_layers(self):
             self.assertEqual(len(bits), 1)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
     #
     @multi_card
     def test_multi_card(self):
@@ -118,6 +119,7 @@ def test_min_target_bits(self):
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
+
     #
     def test_max_target_bits(self):
         model_name = "/models/opt-125m"

From 8ce5b1eec75adfaf30d9bb8781eb9b88e3140376 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Wed, 15 Oct 2025 16:11:57 +0800
Subject: [PATCH 71/88] fix merge issue

---
 auto_round/__main__.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 110107acd..0d4e12985 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -12,9 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import argparse
-import logging
 import os
-import re
 import sys
 
 from auto_round.compressors import BaseCompressor
@@ -24,7 +22,6 @@
     clear_memory,
     get_device_and_parallelism,
     get_model_dtype,
-    set_cuda_visible_devices,
 )
 
 RECIPES = {
@@ -82,7 +79,7 @@ def __init__(self, *args, **kwargs):
         self.add_argument("--act_bits", default=None, type=int, help="activation bits")
         self.add_argument("--act_group_size", default=None, type=int, help="activation group size")
         self.add_argument(
-            "--super_group_size", default=None, type=int, help="the number of super group size when use double quant."
+            "--super_group_size", default=None, type=int, help="the number of super group size when use double quant.")
         basic.add_argument(
             "--iters",
             "--iter",
@@ -469,8 +466,6 @@ def tune(args):
     if "marlin" in args.format and args.asym is True:
         raise RuntimeError("marlin backend only supports sym quantization, please remove --asym")
 
-    # Must set this before import torch
-    # set_cuda_visible_devices(args.device_map)
     device_str, use_auto_mapping = get_device_and_parallelism(args.device_map)
 
     import torch

From 8e163257bee9cfad30ce86e7c2172bbb9da9da67 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 15 Oct 2025 08:12:48 +0000
Subject: [PATCH 72/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/__main__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 0d4e12985..3468cedb1 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -79,7 +79,8 @@ def __init__(self, *args, **kwargs):
         self.add_argument("--act_bits", default=None, type=int, help="activation bits")
         self.add_argument("--act_group_size", default=None, type=int, help="activation group size")
         self.add_argument(
-            "--super_group_size", default=None, type=int, help="the number of super group size when use double quant.")
+            "--super_group_size", default=None, type=int, help="the number of super group size when use double quant."
+        )
         basic.add_argument(
             "--iters",
             "--iter",

From decdcce5ebe3ee621822fb60ce3fe8c333541f43 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Wed, 15 Oct 2025 16:47:13 +0800
Subject: [PATCH 73/88] fix merge issue

---
 README.md                      |  9 +++++--
 auto_round/__main__.py         |  8 ------
 auto_round/compressors/base.py | 47 ++++++++++------------------------
 auto_round/utils.py            |  2 +-
 4 files changed, 22 insertions(+), 44 deletions(-)

diff --git a/README.md b/README.md
index bbebb901c..f00e8d0b1 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,8 @@ and [fbaldassarri](https://huggingface.co/fbaldassarri). For usage instructions,
 
 
 ## 🆕 What's New
+[2025/10] AutoRound now includes experimental support for a fast algorithm developed by the AutoRound team for generating mixed-bit and data-type schemes. See the documentation
+ for accuracy results and this Doc for usage
 
 [2025/09] AutoRound now includes experimental support for the mxfp4 and nvfp4 dtypes. For accuracy results, see the [documentation](./docs/mxnv_acc.md)
 . We currently recommend exporting to the LLM-Compressor format.
@@ -38,7 +40,7 @@ and [fbaldassarri](https://huggingface.co/fbaldassarri). For usage instructions,
   all bits other than 3 bits. Example
   models: [Intel/Qwen3-235B-A22B-q2ks-mixed-AutoRound](https://huggingface.co/Intel/Qwen3-235B-A22B-q2ks-mixed-AutoRound)
   and [Intel/DeepSeek-R1-0528-q2ks-mixed-AutoRound](https://huggingface.co/Intel/DeepSeek-R1-0528-q2ks-mixed-AutoRound). **A more advanced algorithm** tailored for specific configurations may be available in
-  v0.7.1.
+  v0.8.1.
 
 [2025/05] AutoRound has been integrated into **vLLM**. You can now run models in the AutoRound format directly with
   vLLM versions later than v0.85.post1.
@@ -65,6 +67,9 @@ Support **AutoRound, AutoAWQ, AutoGPTQ, and GGUF** for maximum compatibility. De
 ✅ **Affordable Quantization Cost**
 Quantize 7B models in about 10 minutes on a single GPU. Details are shown in [quantization costs](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#quantization-costs)
 
+✅ **Fast mixed-bit/data-type scheme generation**
+Achieve automatic configuration in minutes, with only ~2× VRAM overhead.
+
 ✅ **10+ VLMs Support**
 Out-of-the-box quantization for 10+ vision-language models [example models](https://huggingface.co/collections/OPEA/vlms-autoround-675bc712fdd6a55ebaf11bfa), [support matrix](https://github.com/intel/auto-round/tree/main/auto_round/mllm#support-matrix)
 
@@ -111,7 +116,7 @@ pip install auto-round-lib
 ## Model Quantization (CPU/Intel GPU/Gaudi/CUDA)
 
 ### CLI Usage
-Please change to `auto-round-mllm` for visual-language models (VLMs) quantization. The full list of supported arguments is provided by calling `auto-round -h` on the terminal.
+The full list of supported arguments is provided by calling `auto-round -h` on the terminal.
 
 ```bash
 auto-round \
diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 0d4e12985..2f4d7d71b 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -72,14 +72,6 @@ def __init__(self, *args, **kwargs):
             action="store_true",
             help="for auto scheme whether ignore scale zp bits calculation ",
         )
-        self.add_argument("--bits", default=None, type=int, help="number of weight bits")
-        self.add_argument("--group_size", default=None, type=int, help="group size")
-        self.add_argument("--asym", action="store_true", help="whether to use asym quantization")
-        self.add_argument("--data_type", "--dtype", default=None, help="data type for tuning, 'int', 'mx_fp' and etc")
-        self.add_argument("--act_bits", default=None, type=int, help="activation bits")
-        self.add_argument("--act_group_size", default=None, type=int, help="activation group size")
-        self.add_argument(
-            "--super_group_size", default=None, type=int, help="the number of super group size when use double quant.")
         basic.add_argument(
             "--iters",
             "--iter",
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index d5110348c..bc5f09e4d 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -1676,40 +1676,21 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
 
         # TODO check scale_dtype
         if not self.is_auto_scheme:
-            self.layer_config, self.has_qlayer_outside_block = set_layer_config(
-                self.model,
-                self.layer_config,
-                self.scheme,
-                self.scale_dtype,
-                self.supported_types,
-                self.inner_supported_types,
-                self.quant_block_list,
-                self.fp_layers,
-                self.quant_lm_head,
-                enable_gguf_official_mixed=True,
-                is_mllm=self.mllm,
-            )
+            enable_gguf_official_mixed = True
         else:
-            # for n, scheme in self.layer_config.items():
-            #     module = get_module(self.model, n)
-            #     if not isinstance(scheme, dict):
-            #         raise ValueError("scheme return by scheme should be dict")
-            #     for key, item in scheme.items():
-            #         setattr(module, key, item)
-            #     # set_extra scale_dtype
-            #     module.scale_dtype = self.scale_dtype
-            self.layer_config, self.has_qlayer_outside_block = set_layer_config(
-                self.model,
-                self.layer_config,
-                self.scheme,
-                self.scale_dtype,
-                self.supported_types,
-                self.inner_supported_types,
-                self.quant_block_list,
-                self.fp_layers,
-                self.quant_lm_head,
-                enable_gguf_official_mixed=False,
-                is_mllm=self.mllm,
+            enable_gguf_official_mixed = False
+        self.layer_config, self.has_qlayer_outside_block = set_layer_config(
+            self.model,
+            self.layer_config,
+            self.scheme,
+            self.scale_dtype,
+            self.supported_types,
+            self.inner_supported_types,
+            self.quant_block_list,
+            self.fp_layers,
+            self.quant_lm_head,
+            enable_gguf_official_mixed=enable_gguf_official_mixed,
+            is_mllm=self.mllm,
             )
 
         if not hasattr(self, "formats"):
diff --git a/auto_round/utils.py b/auto_round/utils.py
index f212acd28..380383f0e 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2855,7 +2855,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         elif isinstance(item, QuantizationScheme):
             config = asdict(item)
         elif isinstance(item, dict):
-            invalid = set(item) - set(scheme_keys)
+            invalid = set(item) - set(scheme_keys+("fixed_by_user", "scale_dtype"))
             if invalid:
                 raise ValueError(
                     f"Invalid keys {invalid} in layer_config for '{layer_name}'. " f"Allowed keys: {scheme_keys}"

From f9e80abf428e278160c3f4d6c033d753182c44e0 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 15 Oct 2025 08:51:47 +0000
Subject: [PATCH 74/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py | 2 +-
 auto_round/utils.py            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index bc5f09e4d..d8238a0de 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -1691,7 +1691,7 @@ def quantize(self) -> tuple[torch.nn.Module, dict[str, Any]]:
             self.quant_lm_head,
             enable_gguf_official_mixed=enable_gguf_official_mixed,
             is_mllm=self.mllm,
-            )
+        )
 
         if not hasattr(self, "formats"):
             logger.warning("this API is deprecated, please use `quantize_and_save` instead")
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 380383f0e..bc8b02dd5 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -2855,7 +2855,7 @@ def normalize_item(item: Union[str, dict, "QuantizationScheme"], layer_name: str
         elif isinstance(item, QuantizationScheme):
             config = asdict(item)
         elif isinstance(item, dict):
-            invalid = set(item) - set(scheme_keys+("fixed_by_user", "scale_dtype"))
+            invalid = set(item) - set(scheme_keys + ("fixed_by_user", "scale_dtype"))
             if invalid:
                 raise ValueError(
                     f"Invalid keys {invalid} in layer_config for '{layer_name}'. " f"Allowed keys: {scheme_keys}"

From efc69de1fd7c1e7754bcbf1c7f6d495b05d08920 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Wed, 15 Oct 2025 17:21:28 +0800
Subject: [PATCH 75/88] update

---
 auto_round/__main__.py                        |  6 ---
 .../{auto_schemes => auto_scheme}/__init__.py |  8 +--
 .../gen_auto_scheme.py                        |  6 +--
 .../{auto_schemes => auto_scheme}/utils.py    |  0
 auto_round/compressors/base.py                |  2 +-
 docs/alg_202508.md                            | 12 ++---
 docs/auto_scheme_acc.md                       | 51 +++++++++++++++++++
 test/test_cuda/test_auto_scheme.py            |  4 +-
 8 files changed, 67 insertions(+), 22 deletions(-)
 rename auto_round/{auto_schemes => auto_scheme}/__init__.py (84%)
 rename auto_round/{auto_schemes => auto_scheme}/gen_auto_scheme.py (96%)
 rename auto_round/{auto_schemes => auto_scheme}/utils.py (100%)
 create mode 100644 docs/auto_scheme_acc.md

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index 2f4d7d71b..a9cc01985 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -554,12 +554,6 @@ def tune(args):
     extra_config.diffusion_config = diffusion_config
 
     layer_config = {}
-    # from auto_round.auto_schemes.haha import get_mixed_config_layer_config
-    # layer_config = {}
-    # best_path = get_mixed_config_layer_config(model_name, target_bits=3)
-    # for item in best_path:
-    #     layer_config[item[0]] = {}
-    #     layer_config[item[0]]["bits"] = item[1]
 
     if args.avg_bits is not None:
         if args.options is None:
diff --git a/auto_round/auto_schemes/__init__.py b/auto_round/auto_scheme/__init__.py
similarity index 84%
rename from auto_round/auto_schemes/__init__.py
rename to auto_round/auto_scheme/__init__.py
index e0e5ccb66..d6db762ef 100644
--- a/auto_round/auto_schemes/__init__.py
+++ b/auto_round/auto_scheme/__init__.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-AUTO_SCHEMES_METHODS = {}
+AUTO_SCHEME_METHODS = {}
 
 
 def register_scheme_methods(names):
@@ -30,13 +30,13 @@ def register_scheme_methods(names):
     def register(alg):
         if isinstance(names, (tuple, list)):
             for name in names:
-                AUTO_SCHEMES_METHODS[name] = alg
+                AUTO_SCHEME_METHODS[name] = alg
         else:
-            AUTO_SCHEMES_METHODS[names] = alg
+            AUTO_SCHEME_METHODS[names] = alg
 
         return alg
 
     return register
 
 
-import auto_round.auto_schemes.haha  # pylint: disable=E0611,E0401
+import auto_round.auto_scheme.haha  # pylint: disable=E0611,E0401
diff --git a/auto_round/auto_schemes/gen_auto_scheme.py b/auto_round/auto_scheme/gen_auto_scheme.py
similarity index 96%
rename from auto_round/auto_schemes/gen_auto_scheme.py
rename to auto_round/auto_scheme/gen_auto_scheme.py
index 106e3d46d..fb430e3fb 100644
--- a/auto_round/auto_schemes/gen_auto_scheme.py
+++ b/auto_round/auto_scheme/gen_auto_scheme.py
@@ -18,8 +18,8 @@
 import torch
 
 from auto_round import AutoScheme
-from auto_round.auto_schemes import AUTO_SCHEMES_METHODS
-from auto_round.auto_schemes.utils import compute_avg_bits_for_scheme
+from auto_round.auto_scheme import AUTO_SCHEME_METHODS
+from auto_round.auto_scheme.utils import compute_avg_bits_for_scheme
 from auto_round.export.export_to_gguf.config import GGUF_INNER_CONFIG
 from auto_round.logger import logger
 from auto_round.utils import _gguf_type_fallback, get_layer_features, get_module
@@ -73,7 +73,7 @@ def _check_configs(self) -> None:
 
     def get_layer_config(self) -> dict[str, dict]:
         method_name = self.auto_scheme.method
-        method_func = AUTO_SCHEMES_METHODS[method_name]
+        method_func = AUTO_SCHEME_METHODS[method_name]
         layer_config = method_func(
             self.auto_scheme,
             self.model,
diff --git a/auto_round/auto_schemes/utils.py b/auto_round/auto_scheme/utils.py
similarity index 100%
rename from auto_round/auto_schemes/utils.py
rename to auto_round/auto_scheme/utils.py
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index d8238a0de..0f3c4c57b 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -376,7 +376,7 @@ def __init__(
             }
 
             # mainly using quant_layers and fixed by users
-            from auto_round.auto_schemes.gen_auto_scheme import GenScheme
+            from auto_round.auto_scheme.gen_auto_scheme import GenScheme
 
             gen_scheme = GenScheme(
                 scheme,
diff --git a/docs/alg_202508.md b/docs/alg_202508.md
index 3fb74ace8..086cd5cf6 100644
--- a/docs/alg_202508.md
+++ b/docs/alg_202508.md
@@ -3,12 +3,12 @@ We use **lm-eval** for evaluation. For LLaMA, we enabled `add_bos_token` and
 in [modeling_llama.py](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py#L52C1-L52C40)
 to stabilize accuracy during evaluation. All other settings follow the default configurations of AutoRound and lm-eval.
 
-| Qwen3-8B W2G64 | Avg.   | arc_challenge | hellaswag | gsm8k  | lambada_openai | mmlu   | mmlupro | truthfulqa_mc1 | winogrande |
-|----------------|--------|---------------|-----------|--------|----------------|--------|---------|----------------|------------|
-| origin         | 0.4373 | 0.4019        | 0.4437    | 0.4215 | 0.4826         | 0.5474 | 0.263   | 0.3072         | 0.6314     |
-| new            | 0.4787 | 0.4275        | 0.4516    | 0.5944 | 0.5181         | 0.5773 | 0.2807  | 0.3305         | 0.6496     |
+| Qwen3-8B W2G64    | Avg.   | arc_challenge | hellaswag | gsm8k  | lambada_openai | mmlu   | mmlupro | truthfulqa_mc1 | winogrande |
+|-------------------|--------|---------------|-----------|--------|----------------|--------|---------|----------------|------------|
+| AutoRound         | 0.4373 | 0.4019        | 0.4437    | 0.4215 | 0.4826         | 0.5474 | 0.263   | 0.3072         | 0.6314     |
+| AutoRound+alg_ext | 0.4787 | 0.4275        | 0.4516    | 0.5944 | 0.5181         | 0.5773 | 0.2807  | 0.3305         | 0.6496     |
 
 | Llama3.1-8B W2G64 | Avg.   | arc_challenge | hellaswag | gsm8k  | lambada_openai | mmlu   | mmlupro | truthfulqa_mc1 | winogrande |
 |-------------------|--------|---------------|-----------|--------|----------------|--------|---------|----------------|------------|
-| origin            | 0.382  | 0.3635        | 0.4562    | 0.1622 | 0.5069         | 0.4411 | 0.1661  | 0.3207         | 0.6393     |
-| new               | 0.4166 | 0.3712        | 0.4729    | 0.2039 | 0.5946         | 0.4981 | 0.2163  | 0.3011         | 0.6748     |
\ No newline at end of file
+| AutoRound         | 0.382  | 0.3635        | 0.4562    | 0.1622 | 0.5069         | 0.4411 | 0.1661  | 0.3207         | 0.6393     |
+| AutoRound+alg_ext | 0.4166 | 0.3712        | 0.4729    | 0.2039 | 0.5946         | 0.4981 | 0.2163  | 0.3011         | 0.6748     |
\ No newline at end of file
diff --git a/docs/auto_scheme_acc.md b/docs/auto_scheme_acc.md
new file mode 100644
index 000000000..3a284d73a
--- /dev/null
+++ b/docs/auto_scheme_acc.md
@@ -0,0 +1,51 @@
+We use **lm-eval** for evaluation. For LLaMA, we enabled `add_bos_token` and
+`removed @use_kernel_forward_from_hub("RMSNorm")`
+in [modeling_llama.py](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py#L52C1-L52C40)
+to stabilize accuracy during evaluation. All other settings follow the default configurations of AutoRound and lm-eval.
+
+We ignore the scale and zp bits in the tables below. The accuracy may change a little as we modified a little of the
+implementation. We will rerun all the experiments.
+
+For mxfp experiment, we use fake model while for weight only model we use real model. **No tuning is applied unless explict stated.
+**
+
+*Average accuracy across `lambada_openai`, `hellaswag`, `piqa`, `winogrande`, and `mmlu`.*
+
+### Table 1 MXFP4/8 mixed accuracy.
+
+| Average bits     | Llama3.1-8B-I  | Qwen2.5-7B-I   | Qwen3-8B       | Qwen3-32B      |
+|------------------|----------------|----------------|----------------|----------------|
+| **BF16**         | 0.7076 (100%)  | 0.7075 (100%)  | 0.6764 (100%)  | 0.7321 (100%)  |
+| **Pure 4-bit**   | 0.6626 (93.6%) | 0.6550 (92.6%) | 0.6316 (93.4%) | 0.6901 (94.3%) |
+| **Ours 4.5-bit** | 0.6808 (96.2%) | 0.6776 (95.8%) | 0.6550 (96.8%) | 0.7176 (98.0%) |
+| **Ours 5-bit**   | 0.6857 (96.9%) | 0.6823 (96.4%) | 0.6594 (97.5%) | 0.7201 (98.3%) |
+| **Ours 6-bit**   | 0.6975 (98.6%) | 0.6970 (98.5%) | 0.6716 (99.3%) | 0.7303 (99.8%) |
+
+We compare the proposed method against naive layer-wise bit allocation strategies, such as assigning higher
+precision to the network’s head((near lm-head) or tailad(close to embedding)) layers, to demonstrate its relative
+performance advantages.
+
+### Table 2  Comparison with other recipes at an average of 5 bits of mxfp datatype
+
+| Avg. bits = 5         |      Llama3.1-8B-I |       Qwen2.5-7B-I |           Qwen3-8B |
+|-----------------------|-------------------:|-------------------:|-------------------:|
+| **Tail layers 8-bit** |     0.6671 (94.3%) |     0.6616 (93.5%) |     0.6410 (94.8%) |
+| **Head layers 8-bit** |     0.6657 (94.1%) |     0.6686 (94.5%) |     0.6356 (94.0%) |
+| **Ours**              | **0.6857 (96.9%)** | **0.6823 (96.4%)** | **0.6594 (97.5%)** |
+
+### Table 3  Comparison with other recipes at an average of 4.5 bits of mxfp datatype
+
+| Avg. bits = 4.5       |      Llama3.1-8B-I |       Qwen2.5-7B-I |           Qwen3-8B |
+|-----------------------|-------------------:|-------------------:|-------------------:|
+| **Tail layers 8-bit** |     0.6614 (93.5%) |     0.6535 (92.4%) |     0.6373 (94.2%) |
+| **Head layers 8-bit** |     0.6568 (92.8%) |     0.6642 (93.9%) |     0.6305 (93.2%) |
+| **Ours**              | **0.6808 (96.2%)** | **0.6776 (95.5%)** | **0.6550 (95.8%)** |
+
+
+### Table4   Comparison with other recipes at an average of 3 bits of W2G128 and W4G128
+
+| Avg. bits = 4.5       | Llama3.1-8B-I | Qwen2.5-7B-I | Qwen3-8B |
+|-----------------------|--------------:|-------------:|---------:|
+| **Tail layers 4-bit** |        0.6058 |       0.3798 |   0.4536 |
+| **Head layers 4-bit** |        0.3198 |       0.3270 |   0.3196 |
+| **Ours**              |        0.6148 |       0.4058 |   0.4862 |
\ No newline at end of file
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 4b5155e6f..69fc21217 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -9,7 +9,7 @@
 sys.path.insert(0, "../..")
 
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
-from auto_round.auto_schemes.utils import compute_avg_bits_for_model
+from auto_round.auto_scheme.utils import compute_avg_bits_for_model
 from auto_round.eval.evaluation import simple_evaluate
 from auto_round.utils import get_module
 
@@ -54,7 +54,7 @@ def test_shared_layers(self):
             ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"),
             ("fc1", "fc2"),
         ]
-        from auto_round.auto_schemes.utils import parse_shared_layers
+        from auto_round.auto_scheme.utils import parse_shared_layers
 
         res = parse_shared_layers(model, shared_layers)
         self.assertEqual(len(res), 24)

From 4d1f8de28d92a126fb33d87a99e0cab95d0ac3af Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 15 Oct 2025 09:22:51 +0000
Subject: [PATCH 76/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 docs/auto_scheme_acc.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/auto_scheme_acc.md b/docs/auto_scheme_acc.md
index 3a284d73a..b058838f6 100644
--- a/docs/auto_scheme_acc.md
+++ b/docs/auto_scheme_acc.md
@@ -6,7 +6,7 @@ to stabilize accuracy during evaluation. All other settings follow the default c
 We ignore the scale and zp bits in the tables below. The accuracy may change a little as we modified a little of the
 implementation. We will rerun all the experiments.
 
-For mxfp experiment, we use fake model while for weight only model we use real model. **No tuning is applied unless explict stated.
+For mxfp experiment, we use fake model while for weight only model we use real model. **No tuning is applied unless explicit stated.
 **
 
 *Average accuracy across `lambada_openai`, `hellaswag`, `piqa`, `winogrande`, and `mmlu`.*

From f1ed097cc78c250191a8077c49e1db972eca734d Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 10:54:33 +0800
Subject: [PATCH 77/88] update

---
 README.md                                 |  8 ++--
 auto_round/auto_scheme/gen_auto_scheme.py | 11 +++--
 auto_round/schemes.py                     | 24 +++++++++-
 auto_round/utils.py                       | 12 ++---
 docs/step_by_step.md                      | 58 ++++++++++++++++++++++-
 test/test_cuda/test_auto_scheme.py        |  5 +-
 6 files changed, 95 insertions(+), 23 deletions(-)

diff --git a/README.md b/README.md
index f00e8d0b1..48e8f8f6f 100644
--- a/README.md
+++ b/README.md
@@ -27,8 +27,8 @@ and [fbaldassarri](https://huggingface.co/fbaldassarri). For usage instructions,
 
 
 ## 🆕 What's New
-[2025/10] AutoRound now includes experimental support for a fast algorithm developed by the AutoRound team for generating mixed-bit and data-type schemes. See the documentation
- for accuracy results and this Doc for usage
+[2025/10] AutoRound now includes experimental support for a fast algorithm developed by the AutoRound team to generate mixed-bit and mixed-datatype schemes.
+Refer to the documentation for accuracy [results](./docs/auto_scheme_acc.md) and [this guide](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#autoscheme) for usage instructions.
 
 [2025/09] AutoRound now includes experimental support for the mxfp4 and nvfp4 dtypes. For accuracy results, see the [documentation](./docs/mxnv_acc.md)
 . We currently recommend exporting to the LLM-Compressor format.
@@ -67,8 +67,8 @@ Support **AutoRound, AutoAWQ, AutoGPTQ, and GGUF** for maximum compatibility. De
 ✅ **Affordable Quantization Cost**
 Quantize 7B models in about 10 minutes on a single GPU. Details are shown in [quantization costs](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#quantization-costs)
 
-✅ **Fast mixed-bit/data-type scheme generation**
-Achieve automatic configuration in minutes, with only ~2× VRAM overhead.
+✅ **Fast mixed bits/data-types scheme generation**
+Automatically configure in minutes, with only about 2.5× the model’s BF16 VRAM size as overhead.
 
 ✅ **10+ VLMs Support**
 Out-of-the-box quantization for 10+ vision-language models [example models](https://huggingface.co/collections/OPEA/vlms-autoround-675bc712fdd6a55ebaf11bfa), [support matrix](https://github.com/intel/auto-round/tree/main/auto_round/mllm#support-matrix)
diff --git a/auto_round/auto_scheme/gen_auto_scheme.py b/auto_round/auto_scheme/gen_auto_scheme.py
index fb430e3fb..fbf83a866 100644
--- a/auto_round/auto_scheme/gen_auto_scheme.py
+++ b/auto_round/auto_scheme/gen_auto_scheme.py
@@ -102,18 +102,19 @@ def fallback_gguf_layer_config(self, layer_config: dict[str, dict]) -> dict[str,
                 continue  # Skip non-GGUF k-quant layers
 
             layer = get_module(self.model, name)
-            input_features = get_layer_features(layer)
+            input_features, out_features = get_layer_features(layer)
+            if input_features is None:
+                continue
 
             # Determine fallback quantization type
             if input_features % 256 != 0 and input_features % 32 != 0:
                 new_type = "gguf:bf16"
             else:
                 bits = scheme["bits"]
-                new_type = f"gguf:q{bits}_0"
-
+                prefix_idx = 0 if scheme["sym"] else 1
+                new_type = f"gguf:q{bits}_" + f"{prefix_idx}"
                 if new_type not in GGUF_INNER_CONFIG:
-                    new_type = f"gguf:q{bits}_1"
-
+                    new_type = f"gguf:q{bits}_" + f"{1-prefix_idx}"
                     if new_type not in GGUF_INNER_CONFIG:
                         current_type = f"gguf:q{bits}_k"
                         new_type = _gguf_type_fallback(current_type)
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 789cbe1cb..5129b4757 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -122,6 +122,27 @@ def is_preset_scheme(name: str) -> bool:
     }
 )
 
+W2A16G64 = QuantizationScheme.from_dict(
+    {
+        "bits": 2,
+        "sym": True,
+        "group_size": 64,
+        "data_type": "int",
+        "act_bits": 16,
+    }
+)
+
+
+W2A16G32 = QuantizationScheme.from_dict(
+    {
+        "bits": 2,
+        "sym": True,
+        "group_size": 32,
+        "data_type": "int",
+        "act_bits": 16,
+    }
+)
+
 W3A16 = QuantizationScheme.from_dict(
     {
         "bits": 3,
@@ -221,7 +242,6 @@ def is_preset_scheme(name: str) -> bool:
     }
 )
 
-
 PRESET_SCHEMES = {
     "W4A16": W4A16,
     "W2A16": W2A16,
@@ -231,6 +251,8 @@ def is_preset_scheme(name: str) -> bool:
     "MXFP8": MXFP8,
     "NVFP4": NVFP4,
     "FPW8A16": FPW8A16,
+    "W2A16G64": W2A16G64,
+    "W2A16G32": W2A16G32,
     "FP8_STATIC": FP8_STATIC,
     "BF16": BF16,
 }
diff --git a/auto_round/utils.py b/auto_round/utils.py
index bc8b02dd5..fc4a2f054 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1997,14 +1997,10 @@ def _set_config(config, target_config):
                     if config.get("super_group_size", None) is not None:
                         new_type = new_type[:bits_index] + str(config["bits"]) + "_k"
                     if config.get("super_group_size", None) is None or new_type not in GGUF_INNER_CONFIG:
-                        if config.get("sym", True):
-                            new_type = new_type[:bits_index] + str(config["bits"]) + "_0"
-                            if new_type not in GGUF_INNER_CONFIG:
-                                new_type = new_type[:bits_index] + str(config["bits"]) + "_1"
-                        if not config.get("sym", True):
-                            new_type = new_type[:bits_index] + str(config["bits"]) + "_1"
-                            if new_type not in GGUF_INNER_CONFIG:
-                                new_type = new_type[:bits_index] + str(config["bits"]) + "_0"
+                        prefix_idx = 0 if config.get("sym", True) else 1
+                        new_type = new_type[:bits_index] + str(config["bits"]) + f"{prefix_idx}"
+                        if new_type not in GGUF_INNER_CONFIG:
+                            new_type = new_type[:bits_index] + str(config["bits"]) + f"{1-prefix_idx}"
                     if new_type not in GGUF_INNER_CONFIG:
                         raise ValueError(
                             f"the setting in layer_config {layer_name} "
diff --git a/docs/step_by_step.md b/docs/step_by_step.md
index 21c41862c..69d14ec1b 100644
--- a/docs/step_by_step.md
+++ b/docs/step_by_step.md
@@ -19,6 +19,10 @@ This document presents step-by-step instructions for auto-round llm quantization
     - [AutoRoundBest recipe](#autoroundbest-recipe)
     - [AutoRoundLight recipe](#autoroundlight-recipe)
     - [Recipe recommendation](#recipe-recommendation)
+  + [AutoScheme](#autoscheme)
+    - [CLI Usage](#cli-usage)
+    - [API Usage](#api-usage-1)
+    - [Hyperparameters in AutoScheme](#hyperparameters-in-autoscheme)
   + [RTN mode](#rtn-mode)
   + [GGUF format](#gguf-format)
   + [Quantization Costs](#quantization-costs)
@@ -116,7 +120,7 @@ AutoRound supports several Schemes:
 - **W3A16**(bits:3,group_size:128,sym:True,act_bits:16)
 - **W2A16**(bits:2,group_size:128,sym:True,act_bits:16)
 - **Mixed bits Weight only**
-- **NVFP4**(data_type:nvfp4,act_data_type:nvfp4,static_global_scale,group_size 16)
+- **NVFP4**(Experimental feature, recommend exporting to llm-compressor format. data_type:nvfp4,act_data_type:nvfp4,static_global_scale,group_size 16)
 - **MXFP4**(**Research feature,no real kernel**, data_type:mxfp4,act_data_type:mxfp4,rceil,group_size 32)
 - **FPW8A16**(**Research feature,no real kernel**, data_type:fp8,act_data_type 16:,group_size 0->per tensor )
 - **FP8_STATIC**(**Research feature,no real kernel**, data_type:fp8,act_data_type:fp8,group_size -1 ->per channel, act_group_size=0->per tensor)
@@ -271,6 +275,58 @@ W2G64 Average Accuracy of 13 tasks and Time Cost Results(Testing was conducted o
 
 </details>
 
+### AutoScheme
+
+AutoScheme provide automatically algorithm to provide mixed bits/data_type quantization recipes.  For some accuracy result, please refer this doc [here](./auto_scheme_acc.md)
+
+**Please note that mixed data types are supported during tuning, but cannot be exported to real models at this time..**
+### CLI Usage
+use `iters=200`for tuning.
+~~~bash
+auto_round \
+  --model_name  $model_name \
+  --avg_bits 6 \
+  --options "mxfp4,mxfp8" \
+  --ignore_scale_zp_bits \
+  --iters 0 \
+  --format fake 
+~~~
+
+### API Usage
+~~~
+avg_bits= 3.0
+scheme = AutoScheme(avg_bits=avg_bits, options=("W2A16G64“, "W4A16","W8A16"))
+ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+ar.quantize_and_save()
+~~~
+
+### Hyperparameters in AutoScheme
+`avg_bits(float)`: Target average bits for the whole model, only to be quantized layer will be counted in the average bits calculation.
+
+`options(Union[str, list[Union[QuantizationScheme, str]])`: the options of quantization schemes to choose from. It could be a string like "W4A16", or a list of strings or QuantizationScheme objects.
+
+`ignore_scale_zp_bits(bool)`: Whether to ignore the bits of scale and zero point in average bits calculation. Default is False.
+
+`shared_layers (Optional[Iterable[Iterable[str]]])`  only supported in API now
+
+In some serving frameworks, certain layers (e.g., QKV or MoE) are fused to accelerate inference. These fused layers may require the same data type and bit configuration. The shared_layers option simplifies this setup by supporting both regex and full-name matching. **Note that regex matching is applied in a block-wise manner.**
+
+
+```python
+from auto_round import AutoRound, AutoScheme
+shared_layers = [
+            ["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
+            ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"),
+            ("fc1", "fc2"),
+        ]
+target_bits = 5.0
+model_name = "facebook/opt-125m"
+scheme = AutoScheme(avg_bits=target_bits, options=("W4A16", "MXFP8"), shared_layers=shared_layers)
+ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
+model, layer_config = ar.quantize()
+```
+
+
 ### RTN mode
 AutoRound also supports RTN (Round-To-Nearest) mode for fast, calibration-free baseline quantization. try setting `iters=0` and use `group_size=32` for better results.
 
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 69fc21217..77c6df9c9 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,11 +3,8 @@
 import shutil
 import sys
 import unittest
-
-from auto_round.testing_utils import multi_card
-
 sys.path.insert(0, "../..")
-
+from auto_round.testing_utils import multi_card
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 from auto_round.auto_scheme.utils import compute_avg_bits_for_model
 from auto_round.eval.evaluation import simple_evaluate

From bae03541398574031a6f8ee9365a6ce90cd15957 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 16 Oct 2025 02:55:29 +0000
Subject: [PATCH 78/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 docs/step_by_step.md               | 9 +++++----
 test/test_cuda/test_auto_scheme.py | 3 ++-
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/docs/step_by_step.md b/docs/step_by_step.md
index 69d14ec1b..a92811d3f 100644
--- a/docs/step_by_step.md
+++ b/docs/step_by_step.md
@@ -314,11 +314,12 @@ In some serving frameworks, certain layers (e.g., QKV or MoE) are fused to accel
 
 ```python
 from auto_round import AutoRound, AutoScheme
+
 shared_layers = [
-            ["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
-            ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"),
-            ("fc1", "fc2"),
-        ]
+    ["*.self_attn.k_proj", "v_proj", "q_proj", "out_proj"],
+    ("model.decoder.layers.6.fc1", "model.decoder.layers.6.fc2"),
+    ("fc1", "fc2"),
+]
 target_bits = 5.0
 model_name = "facebook/opt-125m"
 scheme = AutoScheme(avg_bits=target_bits, options=("W4A16", "MXFP8"), shared_layers=shared_layers)
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 77c6df9c9..55500979e 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -3,11 +3,12 @@
 import shutil
 import sys
 import unittest
+
 sys.path.insert(0, "../..")
-from auto_round.testing_utils import multi_card
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 from auto_round.auto_scheme.utils import compute_avg_bits_for_model
 from auto_round.eval.evaluation import simple_evaluate
+from auto_round.testing_utils import multi_card
 from auto_round.utils import get_module
 
 

From e014f417027747e284d9d2ddeddfd51d730e7e5b Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 15:25:48 +0800
Subject: [PATCH 79/88] update

---
 auto_round/__main__.py                    | 15 ++++++------
 auto_round/auto_scheme/__init__.py        |  2 +-
 auto_round/auto_scheme/gen_auto_scheme.py | 29 +++++++++++++----------
 auto_round/schemes.py                     |  2 ++
 auto_round/utils.py                       |  4 ++--
 test/test_cuda/test_auto_scheme.py        |  7 ++----
 6 files changed, 32 insertions(+), 27 deletions(-)

diff --git a/auto_round/__main__.py b/auto_round/__main__.py
index a9cc01985..a3ab6f2e5 100644
--- a/auto_round/__main__.py
+++ b/auto_round/__main__.py
@@ -63,15 +63,11 @@ def __init__(self, *args, **kwargs):
             help="The batch size for tuning/calibration."
             "Larger batch sizes may improve stability but require more memory.",
         )
-        self.add_argument("--avg_bits", default=None, type=float, help="for auto scheme, number of avg weight bits")
-        self.add_argument(
+        basic.add_argument("--avg_bits", default=None, type=float, help="for auto scheme, number of avg weight bits")
+        basic.add_argument(
             "--options", default=None, type=str, help="for auto scheme, options for auto scheme, e.g. 'W4A16,W8A16'"
         )
-        self.add_argument(
-            "--ignore_scale_zp_bits",
-            action="store_true",
-            help="for auto scheme whether ignore scale zp bits calculation ",
-        )
+
         basic.add_argument(
             "--iters",
             "--iter",
@@ -144,6 +140,11 @@ def __init__(self, *args, **kwargs):
         )
 
         tuning = self.add_argument_group("Tuning Arguments")
+        tuning.add_argument(
+            "--ignore_scale_zp_bits",
+            action="store_true",
+            help="for auto scheme whether ignore scale zp bits calculation ",
+        )
         tuning.add_argument(
             "--lr",
             default=None,
diff --git a/auto_round/auto_scheme/__init__.py b/auto_round/auto_scheme/__init__.py
index d6db762ef..cb1bc4056 100644
--- a/auto_round/auto_scheme/__init__.py
+++ b/auto_round/auto_scheme/__init__.py
@@ -39,4 +39,4 @@ def register(alg):
     return register
 
 
-import auto_round.auto_scheme.haha  # pylint: disable=E0611,E0401
+import auto_round.auto_scheme.default_alg  # pylint: disable=E0611,E0401
diff --git a/auto_round/auto_scheme/gen_auto_scheme.py b/auto_round/auto_scheme/gen_auto_scheme.py
index fbf83a866..1e5499904 100644
--- a/auto_round/auto_scheme/gen_auto_scheme.py
+++ b/auto_round/auto_scheme/gen_auto_scheme.py
@@ -29,14 +29,15 @@ class GenScheme:
     """Generate and validate quantization schemes for model layers."""
 
     def __init__(
-        self,
-        auto_scheme: AutoScheme,  # TODO support shared layer
-        model: torch.nn.Module,
-        quant_layer_names: Iterable[str],
-        fixed_layer_scheme: dict[str, dict],
-        dataset: str = "pile-10k",  # TODO use auto-round dataset
-        device_map: Union[str, torch.device, int, dict, None] = None,
-        tokenizer=None,
+            self,
+            auto_scheme: AutoScheme,  # TODO support shared layer
+            model: torch.nn.Module,
+            quant_layer_names: Iterable[str],
+            fixed_layer_scheme: dict[str, dict],
+            dataset: str = "pile-10k",  # TODO use auto-round dataset
+            device_map: Union[str, torch.device, int, dict, None] = None,
+            tokenizer=None,
+            enable_torch_compile=False,
     ):
         self.auto_scheme = auto_scheme
         self.model = model
@@ -44,7 +45,7 @@ def __init__(
         self.quant_layer_names = quant_layer_names
         self.fixed_layer_scheme = fixed_layer_scheme
         self.dataset = dataset
-        self.device_map = device_map
+        self.device_map = device_map if self.auto_scheme.device_map is None else self.auto_scheme.device_map
         self._check_configs()
 
     def _check_configs(self) -> None:
@@ -105,23 +106,27 @@ def fallback_gguf_layer_config(self, layer_config: dict[str, dict]) -> dict[str,
             input_features, out_features = get_layer_features(layer)
             if input_features is None:
                 continue
+            if input_features % 256 == 0 or isinstance(layer, torch.nn.Embedding):
+                continue
 
             # Determine fallback quantization type
             if input_features % 256 != 0 and input_features % 32 != 0:
                 new_type = "gguf:bf16"
-            else:
+            elif input_features % 256 != 0:
                 bits = scheme["bits"]
                 prefix_idx = 0 if scheme["sym"] else 1
                 new_type = f"gguf:q{bits}_" + f"{prefix_idx}"
                 if new_type not in GGUF_INNER_CONFIG:
-                    new_type = f"gguf:q{bits}_" + f"{1-prefix_idx}"
+                    new_type = f"gguf:q{bits}_" + f"{1 - prefix_idx}"
                     if new_type not in GGUF_INNER_CONFIG:
                         current_type = f"gguf:q{bits}_k"
                         new_type = _gguf_type_fallback(current_type)
 
             # Apply fallback configuration
             target_config = GGUF_INNER_CONFIG[new_type]
-            scheme.update(target_config)
+            for key in scheme.keys():
+                if key in target_config:
+                    scheme[key] = target_config[key]
 
             logger.warning(f"Fallback applied: {name} → {new_type}")
 
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index 5129b4757..cb7e15e47 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -15,6 +15,7 @@
 from copy import deepcopy
 from dataclasses import dataclass, fields
 from typing import Iterable, Optional, Union
+import torch
 
 __all__ = ["QuantizationScheme", "get_gguf_scheme", "preset_name_to_scheme", "AutoScheme"]
 
@@ -295,6 +296,7 @@ class AutoScheme:
     nsamples: Optional[int] = None
     seqlen: Optional[int] = None
     dataset: Optional[str] = None  # Import Notice no comma for each item
+    device_map: Optional[Union[str, torch.device, int, dict]] = None
 
     def __post_init__(self):
         if isinstance(self.options, str):
diff --git a/auto_round/utils.py b/auto_round/utils.py
index fc4a2f054..06f01eef1 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -1998,9 +1998,9 @@ def _set_config(config, target_config):
                         new_type = new_type[:bits_index] + str(config["bits"]) + "_k"
                     if config.get("super_group_size", None) is None or new_type not in GGUF_INNER_CONFIG:
                         prefix_idx = 0 if config.get("sym", True) else 1
-                        new_type = new_type[:bits_index] + str(config["bits"]) + f"{prefix_idx}"
+                        new_type = new_type[:bits_index] + str(config["bits"]) + f"_{prefix_idx}"
                         if new_type not in GGUF_INNER_CONFIG:
-                            new_type = new_type[:bits_index] + str(config["bits"]) + f"{1-prefix_idx}"
+                            new_type = new_type[:bits_index] + str(config["bits"]) + f"_{1-prefix_idx}"
                     if new_type not in GGUF_INNER_CONFIG:
                         raise ValueError(
                             f"the setting in layer_config {layer_name} "
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 55500979e..38e49d4b8 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -37,7 +37,6 @@ def test_gguf(self):
         scheme = AutoScheme(avg_bits=target_bits, options=("GGUF:Q2_K_S", "GGUF:Q4_K_M"), ignore_scale_zp_bits=True)
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, disable_opt_rtn=True)
         model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model, ignore_scale_zp_bits=True)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
@@ -95,7 +94,7 @@ def test_multi_card(self):
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
 
     @multi_card
-    def test_dict_device_map(self):  # TODO rtn mode has bug
+    def test_dict_device_map(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 8.755
         device_map = {"up_proj": 0, "down_proj": 1}
@@ -113,7 +112,6 @@ def test_min_target_bits(self):
         scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
         model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
@@ -125,7 +123,6 @@ def test_max_target_bits(self):
         scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1)
         model, layer_config = ar.quantize()
-        # self.assertLessEqual(layer_config["lm_head"]["bits"], 8)
         avg_bits, _ = compute_avg_bits_for_model(model)
         print(avg_bits)
         assert target_bits - 0.1 < avg_bits <= target_bits + 1e-3
@@ -164,7 +161,7 @@ def test_layer_config(self):
     def test_lm_head_and_mix_dtype(self):
         model_name = "/models/Qwen3-8B"
         target_bits = 6
-        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "W8A16"))
+        scheme = AutoScheme(avg_bits=target_bits, options=("MXFP4", "MXFP8"))
         ar = AutoRound(model=model_name, scheme=scheme, iters=0, nsamples=1, quant_lm_head=True)
         model, layer_config = ar.quantize()
         self.assertLessEqual(layer_config["lm_head"]["bits"], 8)

From 5e1c4e8ab76357856255e9809de1194bfc34ea04 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 16 Oct 2025 07:28:30 +0000
Subject: [PATCH 80/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/auto_scheme/gen_auto_scheme.py | 18 +++++++++---------
 auto_round/schemes.py                     |  1 +
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/auto_round/auto_scheme/gen_auto_scheme.py b/auto_round/auto_scheme/gen_auto_scheme.py
index 1e5499904..d0dc9537f 100644
--- a/auto_round/auto_scheme/gen_auto_scheme.py
+++ b/auto_round/auto_scheme/gen_auto_scheme.py
@@ -29,15 +29,15 @@ class GenScheme:
     """Generate and validate quantization schemes for model layers."""
 
     def __init__(
-            self,
-            auto_scheme: AutoScheme,  # TODO support shared layer
-            model: torch.nn.Module,
-            quant_layer_names: Iterable[str],
-            fixed_layer_scheme: dict[str, dict],
-            dataset: str = "pile-10k",  # TODO use auto-round dataset
-            device_map: Union[str, torch.device, int, dict, None] = None,
-            tokenizer=None,
-            enable_torch_compile=False,
+        self,
+        auto_scheme: AutoScheme,  # TODO support shared layer
+        model: torch.nn.Module,
+        quant_layer_names: Iterable[str],
+        fixed_layer_scheme: dict[str, dict],
+        dataset: str = "pile-10k",  # TODO use auto-round dataset
+        device_map: Union[str, torch.device, int, dict, None] = None,
+        tokenizer=None,
+        enable_torch_compile=False,
     ):
         self.auto_scheme = auto_scheme
         self.model = model
diff --git a/auto_round/schemes.py b/auto_round/schemes.py
index cb7e15e47..81b1cc1f1 100644
--- a/auto_round/schemes.py
+++ b/auto_round/schemes.py
@@ -15,6 +15,7 @@
 from copy import deepcopy
 from dataclasses import dataclass, fields
 from typing import Iterable, Optional, Union
+
 import torch
 
 __all__ = ["QuantizationScheme", "get_gguf_scheme", "preset_name_to_scheme", "AutoScheme"]

From 7715eab5be51a7ff671f5a322d35a06263d2bb4a Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 16:02:25 +0800
Subject: [PATCH 81/88] support torch enable compile

---
 auto_round/auto_scheme/gen_auto_scheme.py |   2 +
 auto_round/compressors/base.py            | 154 ++++++++++++----------
 auto_round/utils.py                       |   2 +-
 test/test_cuda/test_auto_scheme.py        |  11 ++
 4 files changed, 97 insertions(+), 72 deletions(-)

diff --git a/auto_round/auto_scheme/gen_auto_scheme.py b/auto_round/auto_scheme/gen_auto_scheme.py
index d0dc9537f..7e755a30a 100644
--- a/auto_round/auto_scheme/gen_auto_scheme.py
+++ b/auto_round/auto_scheme/gen_auto_scheme.py
@@ -46,6 +46,7 @@ def __init__(
         self.fixed_layer_scheme = fixed_layer_scheme
         self.dataset = dataset
         self.device_map = device_map if self.auto_scheme.device_map is None else self.auto_scheme.device_map
+        self.enable_torch_compile = enable_torch_compile
         self._check_configs()
 
     def _check_configs(self) -> None:
@@ -83,6 +84,7 @@ def get_layer_config(self) -> dict[str, dict]:
             self.dataset,
             self.tokenizer,
             device_map=self.device_map,
+            enable_torch_compile=self.enable_torch_compile,
         )
         layer_config = self.fallback_gguf_layer_config(layer_config)
         return layer_config
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index 4c32bcf38..e1a1be695 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -201,6 +201,9 @@ def __init__(
             ...         "act_group_size": None,
             ...         "act_sym": None,
             ...     },
+            ...     "layer2": {
+            ...         "W8A16"
+            ...      }
             ...     # ...
             ... }
         """
@@ -318,76 +321,11 @@ def __init__(
         if device_map is None:
             device_map = 0
 
-        if isinstance(scheme, AutoScheme):
-            if self.mllm:
-                logger.info("AutoScheme is not yet supported for multimodal LLMs.")
-                sys.exit(-1)
-
-            if getattr(model, "is_fp8", False):
-                logger.info("AutoScheme does not currently support FP8 models.")
-                sys.exit(-1)
-
-            all_dtypes = []
-            for option in scheme.options:
-                # Skip pure BF16 option
-                if option == "BF16":
-                    continue
-
-                # Resolve the quantization scheme or data type
-                dtype = "int"
-                if isinstance(option, str):
-                    option = preset_name_to_scheme(option)
-
-                if isinstance(option, QuantizationScheme):
-                    dtype = option.data_type
-                elif isinstance(option, dict):
-                    dtype = option.get("data_type", "int")
-
-                all_dtypes.append(dtype)
-
-            # Check for mixed data types
-            unique_dtypes = set(all_dtypes)
-            if len(unique_dtypes) > 1:
-                logger.warning(
-                    "Models with mixed data_types "
-                    "cannot yet be exported to real formats except GGUF. "
-                    "Please save the model using the `fake` format for now."
-                )
+        self.enable_torch_compile = enable_torch_compile
+        self._adjust_torch_compile(enable_torch_compile)
 
-            layer_config, self.has_qlayer_outside_block = set_layer_config(
-                self.model,
-                self.layer_config,
-                self.scheme,
-                self.scale_dtype,
-                self.supported_types,
-                self.inner_supported_types,
-                self.quant_block_list,
-                self.fp_layers,
-                self.quant_lm_head,
-                enable_gguf_official_mixed=False,
-                is_mllm=self.mllm,
-            )
-            quant_layer_names = layer_config.keys()
-            scheme_keys = {f.name for f in fields(QuantizationScheme)}
-            fixed_layer_scheme_new = {
-                k: {key: v[key] for key in scheme_keys & v.keys()}
-                for k, v in layer_config.items()
-                if v.get("fixed_by_user", False)
-            }
-
-            # mainly using quant_layers and fixed by users
-            from auto_round.auto_scheme.gen_auto_scheme import GenScheme
-
-            gen_scheme = GenScheme(
-                scheme,
-                self.model,
-                quant_layer_names,
-                fixed_layer_scheme_new,
-                dataset,
-                device_map=device_map,
-                tokenizer=self.tokenizer,
-            )
-            self.layer_config = gen_scheme.get_layer_config()
+        if isinstance(scheme, AutoScheme):
+            self.layer_config = self._gen_auto_scheme(model,scheme,dataset,device_map)
 
         # Set device, must place after model loading
         self._set_device(device_map)
@@ -453,8 +391,7 @@ def __init__(
             self.inner_supported_types = tuple(x for x in INNER_SUPPORTED_LAYER_TYPES if x != "FP8Linear")
         self.batch_dim = None
         self.infer_bs_coeff = 1
-        self.enable_torch_compile = enable_torch_compile
-        self._adjust_torch_compile(enable_torch_compile)
+
         self.block_forward = compile_func(block_forward, self.device) if self.enable_torch_compile else block_forward
         self._check_configs()
         torch.set_printoptions(precision=3, sci_mode=True)
@@ -464,6 +401,81 @@ def __init__(
             import habana_frameworks.torch.core as htcore  # pylint: disable=E0401
             import habana_frameworks.torch.hpu as hthpu  # pylint: disable=E0401]
 
+
+    def _gen_auto_scheme(self,model:torch.nn.Module,scheme:AutoScheme,dataset:str,device_map:Union[str,int,dict,torch.device])->dict[str,dict]:
+        if self.mllm:
+            logger.info("AutoScheme is not yet supported for multimodal LLMs.")
+            sys.exit(-1)
+
+        if getattr(model, "is_fp8", False):
+            logger.info("AutoScheme does not currently support FP8 models.")
+            sys.exit(-1)
+
+        all_dtypes = []
+        for option in scheme.options:
+            # Skip pure BF16 option
+            if option == "BF16":
+                continue
+
+            # Resolve the quantization scheme or data type
+            dtype = "int"
+            if isinstance(option, str):
+                option = preset_name_to_scheme(option)
+
+            if isinstance(option, QuantizationScheme):
+                dtype = option.data_type
+            elif isinstance(option, dict):
+                dtype = option.get("data_type", "int")
+
+            all_dtypes.append(dtype)
+
+        # Check for mixed data types
+        unique_dtypes = set(all_dtypes)
+        if len(unique_dtypes) > 1:
+            logger.warning(
+                "Models with mixed data_types "
+                "cannot yet be exported to real formats except GGUF. "
+                "Please save the model using the `fake` format for now."
+            )
+
+        layer_config, self.has_qlayer_outside_block = set_layer_config(
+            self.model,
+            self.layer_config,
+            self.scheme,
+            self.scale_dtype,
+            self.supported_types,
+            self.inner_supported_types,
+            self.quant_block_list,
+            self.fp_layers,
+            self.quant_lm_head,
+            enable_gguf_official_mixed=False,
+            is_mllm=self.mllm,
+        )
+        quant_layer_names = layer_config.keys()
+        scheme_keys = {f.name for f in fields(QuantizationScheme)}
+        fixed_layer_scheme_new = {
+            k: {key: v[key] for key in scheme_keys & v.keys()}
+            for k, v in layer_config.items()
+            if v.get("fixed_by_user", False)
+        }
+
+        # mainly using quant_layers and fixed by users
+        from auto_round.auto_scheme.gen_auto_scheme import GenScheme
+
+        gen_scheme = GenScheme(
+            scheme,
+            self.model,
+            quant_layer_names,
+            fixed_layer_scheme_new,
+            dataset,
+            device_map=device_map,
+            tokenizer=self.tokenizer,
+            enable_torch_compile=self.enable_torch_compile,
+        )
+        layer_config = gen_scheme.get_layer_config()
+        return layer_config
+
+
     def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         if hasattr(self, "device") and self.device is not None:
             return
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 5c6dd580d..6ed9916b5 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -996,7 +996,7 @@ def compile_func_on_cuda_or_cpu(func):
 
 
 def compile_func(
-    fun: Union[torch.nn.Module, Callable], device: Union[torch.nn.Module, Callable]
+    fun: Union[torch.nn.Module, Callable], device: Union[str,torch.device,int]
 ) -> Union[torch.nn.Module, Callable]:
     """Compile function on the specified device."""
     if "hpu" in str(device):
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 38e49d4b8..7948a3321 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -179,3 +179,14 @@ def test_auto_scheme_export(self):
         print(result["results"]["lambada_openai"]["acc,none"])
         self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
         shutil.rmtree(self.save_dir, ignore_errors=True)
+
+    def test_enable_torch_compile(self):
+        model_name = "/models/opt-125m"
+        scheme = AutoScheme(avg_bits=2, options=("W2A16"),ignore_scale_zp_bits=True)
+        ar = AutoRound(model=model_name, scheme=scheme,enable_torch_compile=True)
+        ar.quantize_and_save(self.save_dir)
+        model_args = f"pretrained={self.save_dir}"
+        result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
+        print(result["results"]["lambada_openai"]["acc,none"])
+        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+        shutil.rmtree(self.save_dir, ignore_errors=True)

From 6f61ee1b0b3a12932de7f075842e705798102ad3 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 16 Oct 2025 08:03:24 +0000
Subject: [PATCH 82/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 auto_round/compressors/base.py     | 8 ++++----
 auto_round/utils.py                | 2 +-
 test/test_cuda/test_auto_scheme.py | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.py
index e1a1be695..1616d4037 100644
--- a/auto_round/compressors/base.py
+++ b/auto_round/compressors/base.py
@@ -325,7 +325,7 @@ def __init__(
         self._adjust_torch_compile(enable_torch_compile)
 
         if isinstance(scheme, AutoScheme):
-            self.layer_config = self._gen_auto_scheme(model,scheme,dataset,device_map)
+            self.layer_config = self._gen_auto_scheme(model, scheme, dataset, device_map)
 
         # Set device, must place after model loading
         self._set_device(device_map)
@@ -401,8 +401,9 @@ def __init__(
             import habana_frameworks.torch.core as htcore  # pylint: disable=E0401
             import habana_frameworks.torch.hpu as hthpu  # pylint: disable=E0401]
 
-
-    def _gen_auto_scheme(self,model:torch.nn.Module,scheme:AutoScheme,dataset:str,device_map:Union[str,int,dict,torch.device])->dict[str,dict]:
+    def _gen_auto_scheme(
+        self, model: torch.nn.Module, scheme: AutoScheme, dataset: str, device_map: Union[str, int, dict, torch.device]
+    ) -> dict[str, dict]:
         if self.mllm:
             logger.info("AutoScheme is not yet supported for multimodal LLMs.")
             sys.exit(-1)
@@ -475,7 +476,6 @@ def _gen_auto_scheme(self,model:torch.nn.Module,scheme:AutoScheme,dataset:str,de
         layer_config = gen_scheme.get_layer_config()
         return layer_config
 
-
     def _set_device(self, device_map: Union[str, torch.device, int, dict]) -> None:
         if hasattr(self, "device") and self.device is not None:
             return
diff --git a/auto_round/utils.py b/auto_round/utils.py
index 6ed9916b5..8c8c9acc5 100644
--- a/auto_round/utils.py
+++ b/auto_round/utils.py
@@ -996,7 +996,7 @@ def compile_func_on_cuda_or_cpu(func):
 
 
 def compile_func(
-    fun: Union[torch.nn.Module, Callable], device: Union[str,torch.device,int]
+    fun: Union[torch.nn.Module, Callable], device: Union[str, torch.device, int]
 ) -> Union[torch.nn.Module, Callable]:
     """Compile function on the specified device."""
     if "hpu" in str(device):
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 7948a3321..96d335625 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -182,8 +182,8 @@ def test_auto_scheme_export(self):
 
     def test_enable_torch_compile(self):
         model_name = "/models/opt-125m"
-        scheme = AutoScheme(avg_bits=2, options=("W2A16"),ignore_scale_zp_bits=True)
-        ar = AutoRound(model=model_name, scheme=scheme,enable_torch_compile=True)
+        scheme = AutoScheme(avg_bits=2, options=("W2A16"), ignore_scale_zp_bits=True)
+        ar = AutoRound(model=model_name, scheme=scheme, enable_torch_compile=True)
         ar.quantize_and_save(self.save_dir)
         model_args = f"pretrained={self.save_dir}"
         result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")

From 7bd62734d2ec496fb5a960c9a9b6b36b32aa13f2 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 16:14:19 +0800
Subject: [PATCH 83/88] add so file and cpu ut

---
 README.md                                  |   2 +-
 auto_round/auto_scheme/default_alg.abi3.so | Bin 0 -> 300664 bytes
 test/test_cpu/test_auto_scheme.py          |  32 +++++++++++++++++++++
 test/test_cuda/test_auto_scheme.py         |   2 +-
 4 files changed, 34 insertions(+), 2 deletions(-)
 create mode 100644 auto_round/auto_scheme/default_alg.abi3.so
 create mode 100644 test/test_cpu/test_auto_scheme.py

diff --git a/README.md b/README.md
index 48e8f8f6f..a28083a16 100644
--- a/README.md
+++ b/README.md
@@ -68,7 +68,7 @@ Support **AutoRound, AutoAWQ, AutoGPTQ, and GGUF** for maximum compatibility. De
 Quantize 7B models in about 10 minutes on a single GPU. Details are shown in [quantization costs](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#quantization-costs)
 
 ✅ **Fast mixed bits/data-types scheme generation**
-Automatically configure in minutes, with only about 2.5× the model’s BF16 VRAM size as overhead.
+Automatically configure in minutes, with about 2X-4X the model’s BF16 VRAM size as overhead.
 
 ✅ **10+ VLMs Support**
 Out-of-the-box quantization for 10+ vision-language models [example models](https://huggingface.co/collections/OPEA/vlms-autoround-675bc712fdd6a55ebaf11bfa), [support matrix](https://github.com/intel/auto-round/tree/main/auto_round/mllm#support-matrix)
diff --git a/auto_round/auto_scheme/default_alg.abi3.so b/auto_round/auto_scheme/default_alg.abi3.so
new file mode 100644
index 0000000000000000000000000000000000000000..052e98273dba44bfe573d8f404e196d0c4c327f1
GIT binary patch
literal 300664
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%0A4oJ^ke{c-kIs@N
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
F{{^Raa((~+

literal 0
HcmV?d00001

diff --git a/test/test_cpu/test_auto_scheme.py b/test/test_cpu/test_auto_scheme.py
new file mode 100644
index 000000000..edfefe818
--- /dev/null
+++ b/test/test_cpu/test_auto_scheme.py
@@ -0,0 +1,32 @@
+import copy
+import re
+import shutil
+import sys
+import unittest
+
+sys.path.insert(0, "../..")
+from auto_round import AutoRound, AutoRoundConfig, AutoScheme
+from auto_round.auto_scheme.utils import compute_avg_bits_for_model
+from auto_round.eval.evaluation import simple_evaluate
+from auto_round.testing_utils import multi_card
+from auto_round.utils import get_module
+
+
+class TestAutoScheme(unittest.TestCase):
+    @classmethod
+    def setUpClass(self):
+        self.save_dir = "./saved"
+        self.tasks = "lambada_openai"
+
+    @classmethod
+    def tearDownClass(self):
+        shutil.rmtree("./saved", ignore_errors=True)
+        shutil.rmtree("runs", ignore_errors=True)
+
+
+    def test_auto_scheme_export(self):
+        model_name = "/models/opt-125m"
+        scheme = AutoScheme(avg_bits=2, options=("W2A16"),nsamples=1,ignore_scale_zp_bits=True)
+        ar = AutoRound(model=model_name, scheme=scheme)
+        ar.quantize_and_save(self.save_dir)
+        shutil.rmtree(self.save_dir, ignore_errors=True)
\ No newline at end of file
diff --git a/test/test_cuda/test_auto_scheme.py b/test/test_cuda/test_auto_scheme.py
index 7948a3321..a044d6b33 100644
--- a/test/test_cuda/test_auto_scheme.py
+++ b/test/test_cuda/test_auto_scheme.py
@@ -188,5 +188,5 @@ def test_enable_torch_compile(self):
         model_args = f"pretrained={self.save_dir}"
         result = simple_evaluate(model="hf", model_args=model_args, tasks="lambada_openai", batch_size="auto")
         print(result["results"]["lambada_openai"]["acc,none"])
-        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.25)
+        self.assertGreater(result["results"]["lambada_openai"]["acc,none"], 0.10)
         shutil.rmtree(self.save_dir, ignore_errors=True)

From 815de02b079681470c397cd6e249f044f9ad5372 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 16 Oct 2025 08:15:20 +0000
Subject: [PATCH 84/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 test/test_cpu/test_auto_scheme.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/test_cpu/test_auto_scheme.py b/test/test_cpu/test_auto_scheme.py
index edfefe818..fdde697a4 100644
--- a/test/test_cpu/test_auto_scheme.py
+++ b/test/test_cpu/test_auto_scheme.py
@@ -23,10 +23,9 @@ def tearDownClass(self):
         shutil.rmtree("./saved", ignore_errors=True)
         shutil.rmtree("runs", ignore_errors=True)
 
-
     def test_auto_scheme_export(self):
         model_name = "/models/opt-125m"
-        scheme = AutoScheme(avg_bits=2, options=("W2A16"),nsamples=1,ignore_scale_zp_bits=True)
+        scheme = AutoScheme(avg_bits=2, options=("W2A16"), nsamples=1, ignore_scale_zp_bits=True)
         ar = AutoRound(model=model_name, scheme=scheme)
         ar.quantize_and_save(self.save_dir)
-        shutil.rmtree(self.save_dir, ignore_errors=True)
\ No newline at end of file
+        shutil.rmtree(self.save_dir, ignore_errors=True)

From 2959aa90b0f237e1d57e5c9ca8ec01ba1fa72ed5 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 16:44:07 +0800
Subject: [PATCH 85/88] correct model path

---
 auto_round/auto_scheme/__init__.py |  2 +-
 test/test_cpu/test_auto_scheme.py  | 10 ++--------
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/auto_round/auto_scheme/__init__.py b/auto_round/auto_scheme/__init__.py
index cb1bc4056..f4a3d2b23 100644
--- a/auto_round/auto_scheme/__init__.py
+++ b/auto_round/auto_scheme/__init__.py
@@ -39,4 +39,4 @@ def register(alg):
     return register
 
 
-import auto_round.auto_scheme.default_alg  # pylint: disable=E0611,E0401
+import auto_round.auto_scheme.default_alg
diff --git a/test/test_cpu/test_auto_scheme.py b/test/test_cpu/test_auto_scheme.py
index fdde697a4..f85162032 100644
--- a/test/test_cpu/test_auto_scheme.py
+++ b/test/test_cpu/test_auto_scheme.py
@@ -1,16 +1,10 @@
-import copy
-import re
+
 import shutil
 import sys
 import unittest
 
 sys.path.insert(0, "../..")
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
-from auto_round.auto_scheme.utils import compute_avg_bits_for_model
-from auto_round.eval.evaluation import simple_evaluate
-from auto_round.testing_utils import multi_card
-from auto_round.utils import get_module
-
 
 class TestAutoScheme(unittest.TestCase):
     @classmethod
@@ -24,7 +18,7 @@ def tearDownClass(self):
         shutil.rmtree("runs", ignore_errors=True)
 
     def test_auto_scheme_export(self):
-        model_name = "/models/opt-125m"
+        model_name = "/tf_dataset/auto_round/models/facebook/opt-125m"
         scheme = AutoScheme(avg_bits=2, options=("W2A16"), nsamples=1, ignore_scale_zp_bits=True)
         ar = AutoRound(model=model_name, scheme=scheme)
         ar.quantize_and_save(self.save_dir)

From 019991fbd4972a89c6788010098b9d2eaa23b86c Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 16 Oct 2025 08:44:56 +0000
Subject: [PATCH 86/88] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 test/test_cpu/test_auto_scheme.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_cpu/test_auto_scheme.py b/test/test_cpu/test_auto_scheme.py
index f85162032..a0eb21001 100644
--- a/test/test_cpu/test_auto_scheme.py
+++ b/test/test_cpu/test_auto_scheme.py
@@ -1,4 +1,3 @@
-
 import shutil
 import sys
 import unittest
@@ -6,6 +5,7 @@
 sys.path.insert(0, "../..")
 from auto_round import AutoRound, AutoRoundConfig, AutoScheme
 
+
 class TestAutoScheme(unittest.TestCase):
     @classmethod
     def setUpClass(self):

From 76f4f8bc92805f2a0bc0a11caac36323911661c8 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 17:28:07 +0800
Subject: [PATCH 87/88] update so

---
 auto_round/auto_scheme/default_alg.abi3.so | Bin 300664 -> 296568 bytes
 docs/step_by_step.md                       |   2 ++
 2 files changed, 2 insertions(+)

diff --git a/auto_round/auto_scheme/default_alg.abi3.so b/auto_round/auto_scheme/default_alg.abi3.so
index 052e98273dba44bfe573d8f404e196d0c4c327f1..9dac1fe7b1054253ed73a5c0257d4a206bf251bd 100644
GIT binary patch
delta 100252
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

delta 106389
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

diff --git a/docs/step_by_step.md b/docs/step_by_step.md
index a92811d3f..d2efdcd72 100644
--- a/docs/step_by_step.md
+++ b/docs/step_by_step.md
@@ -309,6 +309,8 @@ ar.quantize_and_save()
 
 `shared_layers (Optional[Iterable[Iterable[str]]])`  only supported in API now
 
+`device_map (Optional[str,dict,torch.device])`  only supported in API now, as auto-scheme used more VRAM than auto-round tuning, so you could set a different device_map for it.
+
 In some serving frameworks, certain layers (e.g., QKV or MoE) are fused to accelerate inference. These fused layers may require the same data type and bit configuration. The shared_layers option simplifies this setup by supporting both regex and full-name matching. **Note that regex matching is applied in a block-wise manner.**
 
 

From bdf5421e3844e8e24702124d17319fa6bca6a354 Mon Sep 17 00:00:00 2001
From: Wenhua Cheng <wenhua.cheng@intel.com>
Date: Thu, 16 Oct 2025 17:30:19 +0800
Subject: [PATCH 88/88] update readme

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index a28083a16..fcbce0be5 100644
--- a/README.md
+++ b/README.md
@@ -27,8 +27,8 @@ and [fbaldassarri](https://huggingface.co/fbaldassarri). For usage instructions,
 
 
 ## 🆕 What's New
-[2025/10] AutoRound now includes experimental support for a fast algorithm developed by the AutoRound team to generate mixed-bit and mixed-datatype schemes.
-Refer to the documentation for accuracy [results](./docs/auto_scheme_acc.md) and [this guide](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#autoscheme) for usage instructions.
+[2025/10] AutoRound team proposed a fast algorithm to generate mixed bits/datatypes schemes in minutes. Please
+refer to the documentation for accuracy [results](./docs/auto_scheme_acc.md) and [this guide](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#autoscheme) for usage instructions.
 
 [2025/09] AutoRound now includes experimental support for the mxfp4 and nvfp4 dtypes. For accuracy results, see the [documentation](./docs/mxnv_acc.md)
 . We currently recommend exporting to the LLM-Compressor format.