Skip to content

PTQ-Level Efficiency, QAT-Level Accuracy | 训练后量化的效率,量化感知训练的精度

14.6 KB
Raw Blame
from types import SimpleNamespace
from unittest.mock import MagicMock, patch

import pytest
import torch

import auto_round.utils.device as auto_round_utils
from auto_round.utils.common import (
    compress_layer_names,
    expand_layer_config_for_weight_renames,
    get_reverse_checkpoint_conversion_mapping,
    preserve_original_visual_block_name,
    revert_checkpoint_conversion_mapping,
)
from auto_round.utils.model import is_code_model, map_nested_tensors


def test_map_nested_tensors_preserves_structure_without_mutating_input():
    original = {"args": (torch.tensor([1.0]),), "metadata": ["unchanged"]}

    mapped = map_nested_tensors(original, lambda tensor: tensor + 1)

    assert mapped is not original
    assert mapped["args"] is not original["args"]
    torch.testing.assert_close(mapped["args"][0], torch.tensor([2.0]))
    torch.testing.assert_close(original["args"][0], torch.tensor([1.0]))
    assert mapped["metadata"] == ["unchanged"]


@pytest.mark.parametrize(
    "model,config",
    [
        ("Qwen/Qwen3-Coder-30B", None),
        ("/models/CodeLlama-7b", None),
        ("bigcode/starcoder2-15b", None),
        ("generic/model", SimpleNamespace(architectures=["DeepseekCoderForCausalLM"])),
        ("generic/model", SimpleNamespace(finetuning_task="code-generation")),
        ("generic/model", SimpleNamespace(task_specific_params={"text-to-code": {}})),
    ],
)
def test_is_code_model(model, config):
    assert is_code_model(model, config)


@pytest.mark.parametrize(
    "model,config",
    [
        ("Qwen/Qwen3-4B", None),
        ("org/encoder-decoder", None),
        ("org/audio-codec", None),
        ("/srv/code/checkpoints/Llama-3", None),
        ("org/notstarcoder-model", None),
        ("generic/model", SimpleNamespace(_name_or_path="/srv/code/checkpoints/Llama-3")),
        ("generic/model", SimpleNamespace(architectures=["SomeEncoderDecoderModel"])),
    ],
)
def test_is_not_code_model(model, config):
    assert not is_code_model(model, config)


class TestPackingWithNumba:

    @patch.object(auto_round_utils, "_is_tbb_installed", lambda: False)
    def test_tbb_not_installed(self):
        assert auto_round_utils.is_tbb_available() is False, "`is_tbb_available` should return False."
        assert auto_round_utils.can_pack_with_numba() is False, "`can_pack_with_numba` should return False."

    @patch.object(auto_round_utils, "_is_tbb_installed", lambda: True)
    @patch.object(auto_round_utils, "_is_tbb_configured", lambda: False)
    def test_tbb_installed_but_not_configured_right(self):
        assert auto_round_utils.is_tbb_available() is False, "`is_tbb_available` should return False."
        assert auto_round_utils.can_pack_with_numba() is False, "`can_pack_with_numba` should return False."

    @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_revert_checkpoint_conversion_mapping_does_not_rewrite_quantized_tensor_suffixes():
    mapping = {"weight": [".weight_packed", ".weight_scale", ".weight_shape"]}

    assert (
        revert_checkpoint_conversion_mapping("model.layers.0.mlp.down_proj.weight", mapping)
        == "model.layers.0.mlp.down_proj.weight_packed"
    )
    assert (
        revert_checkpoint_conversion_mapping("model.layers.0.mlp.down_proj.weight_packed", mapping)
        == "model.layers.0.mlp.down_proj.weight_packed"
    )
    assert (
        revert_checkpoint_conversion_mapping("model.layers.0.mlp.down_proj.weight_scale", mapping)
        == "model.layers.0.mlp.down_proj.weight_scale"
    )


def test_revert_checkpoint_conversion_mapping_handles_backreference_patterns():
    mapping = {r"^model\.language_model\.(.+)$": r"model.\1"}

    converted = revert_checkpoint_conversion_mapping("model.language_model.layers.0.self_attn.q_proj.weight", mapping)

    assert converted == "model.layers.0.self_attn.q_proj.weight"


def test_get_reverse_checkpoint_conversion_mapping_falls_back_to_central_registry():
    # Models built from config (AutoRound's meta / disk-stream skeleton) are not
    # created through ``from_pretrained`` and therefore carry no
    # ``_weight_conversions``. The reverse map must still be recovered from
    # transformers' central per-family registry (transformers >= 5.x), otherwise
    # module-side names such as ``attn_hc.base`` are written to the checkpoint
    # verbatim and break reload (e.g. vLLM ``KeyError: 'layers.0.attn_hc.base'``).
    pytest.importorskip("transformers.conversion_mapping")
    from transformers.conversion_mapping import get_checkpoint_conversion_mapping as _tf_mapping

    if not _tf_mapping("glm5_next"):
        pytest.skip("installed transformers has no glm5_next conversion mapping")

    model = SimpleNamespace(config=SimpleNamespace(model_type="glm5_next"))
    reverse_mapping = get_reverse_checkpoint_conversion_mapping(model)

    # attn_hc.base -> hc_attn_base is the exact rename that broke vLLM deployment.
    assert (
        revert_checkpoint_conversion_mapping("model.language_model.layers.0.attn_hc.base", reverse_mapping)
        == "model.language_model.layers.0.hc_attn_base"
    )
    assert (
        revert_checkpoint_conversion_mapping("model.language_model.layers.3.ffn_hc.scale", reverse_mapping)
        == "model.language_model.layers.3.hc_ffn_scale"
    )
    # The forget-gate submodule renames must reverse too, to avoid the next KeyError.
    assert (
        revert_checkpoint_conversion_mapping(
            "model.language_model.layers.0.self_attn.forget_gate.A_log", reverse_mapping
        )
        == "model.language_model.layers.0.self_attn.A_log"
    )


def test_expand_layer_config_for_weight_renames_to_model_names(monkeypatch):
    checkpoint_name = "language_model.model.layers.0.self_attn.q_proj"
    model_name = "model.language_model.layers.0.self_attn.q_proj"
    monkeypatch.setattr(
        "auto_round.utils.common.get_reverse_checkpoint_conversion_mapping",
        lambda model: {
            r"model.language_model": r"language_model",
            r"language_model": r"language_model.model",
        },
    )

    expanded = expand_layer_config_for_weight_renames(
        {checkpoint_name: {"bits": 4}},
        model=SimpleNamespace(),
        to_model_names=True,
    )

    assert expanded[checkpoint_name]["bits"] == 4
    assert expanded[model_name]["bits"] == 4


def test_expand_layer_config_for_weight_renames_to_checkpoint_names(monkeypatch):
    model_name = "model.layers.0.attn_hc.base"
    checkpoint_name = "model.layers.0.hc_attn_base"
    monkeypatch.setattr(
        "auto_round.utils.common.get_reverse_checkpoint_conversion_mapping",
        lambda model: {r"attn_hc\.base$": "hc_attn_base"},
    )

    expanded = expand_layer_config_for_weight_renames(
        {model_name: {"bits": 4}},
        model_type="glm5_next",
        to_model_names=False,
    )

    assert expanded[model_name]["bits"] == 4
    assert expanded[checkpoint_name]["bits"] == 4


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"
    )


class TestPredefinedIgnoreLayersBlockFilter:
    """Test the block-prefix filter in configure_layer_config."""

    @staticmethod
    def _make_compressor_stub(predefined_ignore_layers, quant_block_list):
        """Create a minimal stub that allows calling configure_layer_config."""
        from auto_round.compressors.base import BaseOrchestrator as BaseCompressor

        stub = object.__new__(BaseCompressor)
        # Minimal attributes required by configure_layer_config
        stub.ignore_layers = ""
        stub.quant_block_list = quant_block_list
        stub.is_auto_scheme = False
        stub.orig_scheme = "W4A16"
        stub.layer_config = None
        stub.quant_lm_head = False
        stub.scale_dtype = "fp16"

        # Mock compress_context (no gguf format)
        stub.compress_context = MagicMock()
        stub.compress_context.formats = None

        # Mock model_context with a fake model
        stub.model_context = MagicMock()
        stub.model_context.model = MagicMock()
        stub.model_context.is_mllm = False

        return stub

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_kimi_k25_ignore_layers_preserved(self, mock_handle, mock_set_lc, mock_get_predefined):
        """KIMI K2.5: vision_tower and mm_projector must end up in ignore_layers."""
        mock_get_predefined.return_value = ["vision_tower", "mm_projector"]
        mock_set_lc.return_value = {}

        stub = self._make_compressor_stub(
            predefined_ignore_layers=["vision_tower", "mm_projector"],
            quant_block_list=[["model.layers"]],
        )
        stub.configure_layer_config()

        assert (
            "vision_tower" in stub.ignore_layers
        ), f"vision_tower should be in ignore_layers, got: '{stub.ignore_layers}'"
        assert (
            "mm_projector" in stub.ignore_layers
        ), f"mm_projector should be in ignore_layers, got: '{stub.ignore_layers}'"

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_none_ignore_layers_accepts_predefined_layers(self, mock_handle, mock_set_lc, mock_get_predefined):
        mock_get_predefined.return_value = ["vision_tower", "mm_projector"]
        mock_set_lc.return_value = {}
        stub = self._make_compressor_stub(
            predefined_ignore_layers=["vision_tower", "mm_projector"],
            quant_block_list=[["model.layers"]],
        )
        stub.ignore_layers = None

        stub.configure_layer_config()

        assert stub.ignore_layers == "vision_tower,mm_projector"

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_step3p5_ignore_layers_preserved(self, mock_handle, mock_set_lc, mock_get_predefined):
        """step3p5: short pattern names must not be dropped by block filter."""
        predefined = ["g_proj", "moe.gate", "eh_proj", "shared_head", "layers.45"]
        mock_get_predefined.return_value = predefined
        mock_set_lc.return_value = {}

        stub = self._make_compressor_stub(
            predefined_ignore_layers=predefined,
            quant_block_list=[["model.layers"]],
        )
        stub.configure_layer_config()

        for name in predefined:
            assert name in stub.ignore_layers, f"'{name}' should be in ignore_layers, got: '{stub.ignore_layers}'"

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_longcat_classifier_preserved(self, mock_handle, mock_set_lc, mock_get_predefined):
        """Longcat: 'classifier' must not be dropped."""
        mock_get_predefined.return_value = ["classifier"]
        mock_set_lc.return_value = {}

        stub = self._make_compressor_stub(
            predefined_ignore_layers=["classifier"],
            quant_block_list=[["model.layers"]],
        )
        stub.configure_layer_config()

        assert "classifier" in stub.ignore_layers, f"classifier should be in ignore_layers, got: '{stub.ignore_layers}'"

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_glm_flash_full_path_inside_block_preserved(self, mock_handle, mock_set_lc, mock_get_predefined):
        """GLM Flash: model.layers.0.mlp (full path inside block) must be kept."""
        mock_get_predefined.return_value = ["model.layers.0.mlp"]
        mock_set_lc.return_value = {}

        stub = self._make_compressor_stub(
            predefined_ignore_layers=["model.layers.0.mlp"],
            quant_block_list=[["model.layers"]],
        )
        stub.configure_layer_config()

        assert (
            "model.layers.0.mlp" in stub.ignore_layers
        ), f"model.layers.0.mlp should be in ignore_layers, got: '{stub.ignore_layers}'"

    @patch("auto_round.compressors.base.get_predefined_ignore_layers")
    @patch("auto_round.compressors.base.resolve_layer_config")
    @patch("auto_round.compressors.base._handle_special_schemes", return_value=None)
    def test_mllm_with_multiple_block_groups(self, mock_handle, mock_set_lc, mock_get_predefined):
        """MLLM with vision + language blocks: ignore layers outside both are preserved."""
        mock_get_predefined.return_value = ["vision_tower", "mm_projector"]
        mock_set_lc.return_value = {}

        stub = self._make_compressor_stub(
            predefined_ignore_layers=["vision_tower", "mm_projector"],
            quant_block_list=[["model.visual.blocks"], ["model.layers"]],
        )
        stub.configure_layer_config()

        assert "vision_tower" in stub.ignore_layers
        assert "mm_projector" in stub.ignore_layers