PTQ-Level Efficiency, QAT-Level Accuracy | 训练后量化的效率,量化感知训练的精度
Fix some CI issues (#1842)
Liang Lvfd495491548f
diff --git a/auto_round/compressors/base.py b/auto_round/compressors/base.pyindex 6f5dc2fda..f651df215 100644--- a/auto_round/compressors/base.py+++ b/auto_round/compressors/base.py@@ -55,6 +55,7 @@ from auto_round.utils import (is_hpex_available,is_quantized_input_module,memory_monitor,+ preserve_original_visual_block_name,revert_checkpoint_conversion_mapping,)from auto_round.utils.device import (@@ -556,14 +557,25 @@ class BaseCompressor(object):def configure_layer_config(self, enable_gguf_official_mixed: bool | None = True) -> None:"""Build ``self.layer_config`` from the resolved scheme on the patched model."""- is_gguf_format = (f := getattr(self.compress_context, "formats", None)) is not None and "gguf" in f+ _formats = getattr(self.compress_context, "formats", None)+ is_gguf_format = _formats is not None and any(+ "gguf" in str(getattr(fmt, "output_format", "")) for fmt in _formats+ )predefined_ignore_layers = get_predefined_ignore_layers(self.model_context.model)compressed_predefined_ignore_layers = compress_layer_names(predefined_ignore_layers)if not is_gguf_format:predefined_ignore_layers = get_predefined_ignore_layers(self.model_context.model)+ if predefined_ignore_layers and self.quant_block_list:+ block_prefixes = [block for group in self.quant_block_list for block in group]+ predefined_ignore_layers = [+ name+ for name in predefined_ignore_layers+ if any(name.startswith(prefix) for prefix in block_prefixes)+ ]+ predefined_ignore_layers = compress_layer_names(predefined_ignore_layers)if predefined_ignore_layers:logger.info(f"Using predefined ignore_layers: {compressed_predefined_ignore_layers}")- tmp_str = ",".join(predefined_ignore_layers)+ tmp_str = predefined_ignore_layers.replace(" ", "")if self.ignore_layers == "":self.ignore_layers = tmp_strelse:@@ -1355,19 +1367,32 @@ class BaseCompressor(object):if "scale_dtype" in serialization_dict.keys():serialization_dict["scale_dtype"] = str(serialization_dict["scale_dtype"])+ original_to_quant_block_names = serialization_dict.get("to_quant_block_names")+ if isinstance(original_to_quant_block_names, list):+ original_to_quant_block_names = original_to_quant_block_names[:]+# to match the original namereverse_checkpoint_conversion_mapping = get_reverse_checkpoint_conversion_mapping(self.model)if isinstance(serialization_dict["to_quant_block_names"], str):- serialization_dict["to_quant_block_names"] = revert_checkpoint_conversion_mapping(+ reverted_block_name = revert_checkpoint_conversion_mapping(serialization_dict["to_quant_block_names"], reverse_checkpoint_conversion_mapping)+ serialization_dict["to_quant_block_names"] = preserve_original_visual_block_name(+ original_to_quant_block_names, reverted_block_name+ )elif isinstance(serialization_dict["to_quant_block_names"], list):for idx in range(len(serialization_dict["to_quant_block_names"])):- serialization_dict["to_quant_block_names"][idx] = revert_checkpoint_conversion_mapping(+ reverted_block_name = revert_checkpoint_conversion_mapping(serialization_dict["to_quant_block_names"][idx], reverse_checkpoint_conversion_mapping)+ original_block_name = None+ if isinstance(original_to_quant_block_names, list) and idx < len(original_to_quant_block_names):+ original_block_name = original_to_quant_block_names[idx]+ serialization_dict["to_quant_block_names"][idx] = preserve_original_visual_block_name(+ original_block_name, reverted_block_name+ )compressed_model = format.save_quantized(save_folder,diff --git a/auto_round/export/export_to_autoround/export.py b/auto_round/export/export_to_autoround/export.pyindex 5246c9503..a394a67d8 100644--- a/auto_round/export/export_to_autoround/export.py+++ b/auto_round/export/export_to_autoround/export.py@@ -280,10 +280,12 @@ def save_quantized_as_autoround(extra_config = {}block_name_to_quantize = quantization_config["block_name_to_quantize"]if isinstance(block_name_to_quantize, str):- block_name_to_quantize = block_name_to_quantize.split(",")+ block_name_to_quantize = [name.strip() for name in block_name_to_quantize.split(",")]elif isinstance(block_name_to_quantize, list):- for i in range(len(block_name_to_quantize)):- block_name_to_quantize[i] = os.path.commonprefix(block_name_to_quantize[i]).rstrip(".")+ block_name_to_quantize = [+ os.path.commonprefix(item).rstrip(".") if isinstance(item, list) else item+ for item in block_name_to_quantize+ ]scheme_keys = [f.name for f in fields(QuantizationScheme)]for layer_name, cfg in layer_config.items():diff --git a/auto_round/export/export_to_gguf/convert.py b/auto_round/export/export_to_gguf/convert.pyindex 78e0089e0..5245f93c4 100644--- a/auto_round/export/export_to_gguf/convert.py+++ b/auto_round/export/export_to_gguf/convert.py@@ -146,7 +146,7 @@ def get_tensors(cls) -> Iterator[tuple[str, Tensor]]:if not hasattr(cls.model, "tensor_name_list"):cls.model.tensor_name_list = []- reverse_key_mapping = {v: k for k, v in cls.model._checkpoint_conversion_mapping.items()}+ reverse_key_mapping = {v: k for k, v in getattr(cls.model, "_checkpoint_conversion_mapping", {}).items()}for name, tensor in cls.model.named_parameters():if name not in cls.model.tensor_name_list:cls.model.tensor_name_list.append(name)diff --git a/auto_round/utils/common.py b/auto_round/utils/common.pyindex 14e9033ac..b80a5ba6f 100644--- a/auto_round/utils/common.py+++ b/auto_round/utils/common.py@@ -1161,6 +1161,9 @@ def get_reverse_checkpoint_conversion_mapping(model):def revert_checkpoint_conversion_mapping(name: str, key_mapping: dict[str, str]) -> str:+ if "," in name:+ return ",".join(revert_checkpoint_conversion_mapping(part, key_mapping) for part in name.split(","))+for source_pattern, target_patterns in key_mapping.items():if isinstance(target_patterns, str):target_patterns = [target_patterns]@@ -1174,6 +1177,42 @@ def revert_checkpoint_conversion_mapping(name: str, key_mapping: dict[str, str])return name+def preserve_original_visual_block_name(original_name: str | None, reverted_name: str) -> str:+ """Keep composite multimodal block prefixes stable in serialized quant configs.++ Some multimodal models expose block names under the composite model path+ (for example ``model.visual.*`` or ``model.language_model.*``) during+ quantization, but checkpoint conversion rules can rewrite those config-only+ block prefixes to text-submodel paths such as ``visual.*`` or+ ``model.layers``. The direct multimodal loaders expect the composite path to+ remain intact in ``block_name_to_quantize``.+ """+ if not (isinstance(original_name, str) and isinstance(reverted_name, str)):+ return reverted_name++ original_parts = [part.strip() for part in original_name.split(",")]+ reverted_parts = [part.strip() for part in reverted_name.split(",")]+ if len(original_parts) != len(reverted_parts):+ return reverted_name++ preserved_parts = []+ for original_part, reverted_part in zip(original_parts, reverted_parts):+ if original_part.startswith("model.visual.") and reverted_part == original_part[len("model.") :]:+ preserved_parts.append(original_part)+ elif original_part.startswith("model.language_model.") and reverted_part.startswith("model.layers"):+ preserved_parts.append(original_part)+ preserved_parts.append(reverted_part)+ else:+ preserved_parts.append(reverted_part)++ deduped_parts = []+ for preserved_part in preserved_parts:+ if preserved_part not in deduped_parts:+ deduped_parts.append(preserved_part)++ return ",".join(deduped_parts)++def apply_checkpoint_conversion_mapping(name: str, key_mapping: dict[str, str]) -> str:for source_pattern, target_patterns in key_mapping.items():if isinstance(target_patterns, str):diff --git a/test/test_cpu/export/test_gguf_format.py b/test/test_cpu/export/test_gguf_format.pyindex e7c9a0584..6eee4cdd1 100644--- a/test/test_cpu/export/test_gguf_format.py+++ b/test/test_cpu/export/test_gguf_format.py@@ -218,7 +218,7 @@ class TestGGUF:assert ar.layer_config["model.embed_tokens"]["bits"] == 8assert "lm_head" not in ar.layer_config- model_name = "Qwen/Qwen3-0.6B"+ model_name = get_model_path("Qwen/Qwen3-0.6B")ar = AutoRound(model=model_name, scheme="gguf:q4_0", iters=0)ar.formats = ["gguf:q4_0"]ar.layer_config, _, _ = set_layer_config(diff --git a/test/test_cpu/models/test_mllm.py b/test/test_cpu/models/test_mllm.pyindex 49b33332a..674b1d718 100644--- a/test/test_cpu/models/test_mllm.py+++ b/test/test_cpu/models/test_mllm.py@@ -236,7 +236,14 @@ class TestAutoRound:model = Qwen2_5_VLForConditionalGeneration.from_pretrained(quantized_model_path, torch_dtype="auto", device_map="auto")- assert model.config.quantization_config.block_name_to_quantize == "model.visual.blocks,model.layers"+ block_name_to_quantize = model.config.quantization_config.block_name_to_quantize+ if isinstance(block_name_to_quantize, str):+ block_name_to_quantize = block_name_to_quantize.split(",")+ assert block_name_to_quantize == [+ "model.visual.blocks",+ "model.language_model.layers",+ "model.layers",+ ]image_url = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg"processor = AutoProcessor.from_pretrained(quantized_model_path)messages = [diff --git a/test/test_cpu/utils/test_utils.py b/test/test_cpu/utils/test_utils.pyindex 3dec97010..1f41074e1 100644--- a/test/test_cpu/utils/test_utils.py+++ b/test/test_cpu/utils/test_utils.py@@ -1,6 +1,10 @@from unittest.mock import patchimport auto_round.utils.device as auto_round_utils+from auto_round.utils.common import (+ preserve_original_visual_block_name,+ revert_checkpoint_conversion_mapping,+)class TestPackingWithNumba:@@ -19,3 +23,43 @@ class TestPackingWithNumba:@patch.object(auto_round_utils, "is_numba_available", lambda: False)def test_numba_not_installed(self):assert auto_round_utils.can_pack_with_numba() is False, "`can_pack_with_numba` should return False."+++def test_revert_checkpoint_conversion_mapping_handles_comma_separated_block_names():+ mapping = {+ r"^visual\.": "model.visual.",+ r"^model\.language_model\.layers": "model.layers",+ }++ converted = revert_checkpoint_conversion_mapping("visual.blocks,model.language_model.layers", mapping)++ assert converted == "model.visual.blocks,model.layers"+++def test_preserve_original_visual_block_name():+ # Single visual block name+ assert preserve_original_visual_block_name("model.visual.blocks", "visual.blocks") == "model.visual.blocks"+ # Comma-separated: visual prefix is preserved and language-model keeps an+ # extra model.layers alias for runtimes that do not use the composite path.+ assert (+ preserve_original_visual_block_name(+ "model.visual.blocks,model.language_model.layers", "visual.blocks,model.layers"+ )+ == "model.visual.blocks,model.language_model.layers,model.layers"+ )+ # Direct language-model composite paths are preserved and also expose the+ # runtime alias used by sglang's text submodel.+ assert (+ preserve_original_visual_block_name("model.language_model.layers", "model.layers")+ == "model.language_model.layers,model.layers"+ )+++def test_preserve_original_mllm_language_block_name():+ assert (+ preserve_original_visual_block_name(+ "model.visual.blocks,model.language_model.layers",+ "model.visual.blocks,model.layers",+ )+ == "model.visual.blocks,model.language_model.layers,model.layers"+ )