PTQ-Level Efficiency, QAT-Level Accuracy | 训练后量化的效率,量化感知训练的精度
# # Copyright (C) 2026 Intel Corporation
# # SPDX-License-Identifier: Apache-2.0
from __future__ import annotations
import copy
import importlib
import importlib.util
import pkgutil
from collections.abc import Callable
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from auto_round.algorithms.base import BaseAlgorithm
@dataclass
class AlgRegistryEntry:
name: str
aliases: tuple[str, ...] = ()
config_factory: Callable[[], object] | None = None
summary: str = ""
alias_factories: dict[str, Callable[[], object]] = field(default_factory=dict)
_ALG_REGISTRY: dict[str, AlgRegistryEntry] = {}
_ALIAS_TO_NAME: dict[str, str] = {}
_CONFIG_IMPL_REGISTRY: dict[type, type[BaseAlgorithm]] = {}
_builtin_algorithms_registered = False
_pipeline_members_registered = False
def _ensure_builtin_algorithms_registered() -> None:
global _builtin_algorithms_registered
if _builtin_algorithms_registered:
return
# Importing each config module triggers its own registration. Keeping the
# imports ordered preserves the help output and default algorithm order.
for module_name in (
"auto_round.algorithms.quantization.rtn.config",
"auto_round.algorithms.quantization.sign_round.config",
"auto_round.algorithms.quantization.qad.config",
"auto_round.algorithms.quantization.qat.config",
"auto_round.algorithms.transforms.awq.config",
"auto_round.algorithms.transforms.svdquant.config",
"auto_round.algorithms.transforms.hadamard.config",
"auto_round.algorithms.transforms.spinquant.preprocessor",
):
importlib.import_module(module_name)
# Optional quantizers own their registration and CLI parameters. Removing
# an experimental package must not require changes to the shared registry.
package = importlib.import_module("auto_round.algorithms.quantization")
for module in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
if module.ispkg:
config_module = module.name + ".config"
if importlib.util.find_spec(config_module) is not None:
importlib.import_module(config_module)
_builtin_algorithms_registered = True
def _ensure_pipeline_members_registered() -> None:
global _pipeline_members_registered
if _pipeline_members_registered:
return
for module_name in (
"auto_round.algorithms.quantization.rtn.quantizer",
"auto_round.algorithms.quantization.sign_round.quantizer",
"auto_round.algorithms.quantization.sign_roundv2.quantizer",
"auto_round.algorithms.quantization.qad.quantizer",
"auto_round.algorithms.quantization.qat.quantizer",
"auto_round.algorithms.quantization.adam_round.adam",
"auto_round.algorithms.transforms.awq.base",
"auto_round.algorithms.transforms.svdquant.apply",
):
importlib.import_module(module_name)
_pipeline_members_registered = True
def register_algorithm(
name: str,
*,
aliases: tuple[str, ...] = (),
config_factory: Callable[[], object] | None = None,
summary: str = "",
alias_factories: dict[str, Callable[[], object]] | None = None,
) -> None:
key = name.strip().lower()
entry = _ALG_REGISTRY.get(key)
if entry is None:
entry = AlgRegistryEntry(name=key)
_ALG_REGISTRY[key] = entry
merged_aliases = tuple(
dict.fromkeys((entry.aliases or ()) + tuple(a.strip().lower() for a in aliases if a.strip()))
)
if config_factory is not None:
entry.config_factory = config_factory
if summary:
entry.summary = summary
if alias_factories:
entry.alias_factories.update({k.strip().lower(): v for k, v in alias_factories.items()})
entry.aliases = merged_aliases
_ALIAS_TO_NAME[key] = key
for alias in merged_aliases:
_ALIAS_TO_NAME[alias] = key
def resolve_algorithm_alias(alias: str) -> str | None:
_ensure_builtin_algorithms_registered()
return _ALIAS_TO_NAME.get(alias.strip().lower())
def resolve_algorithm_names(algorithms) -> list[str]:
"""Resolve one algorithm string or sequence to ordered canonical names.
A comma-separated string and a sequence use exactly the same semantics.
Duplicate aliases are removed while preserving the first occurrence.
"""
if isinstance(algorithms, str):
raw_names = algorithms.split(",")
else:
raw_names = list(algorithms)
canonical_names = []
seen = set()
for raw_name in raw_names:
if not isinstance(raw_name, str):
raise TypeError(f"Algorithm names must be strings, got {type(raw_name).__name__}.")
name = raw_name.strip()
if not name:
continue
canonical = resolve_algorithm_alias(name)
if canonical is None:
raise ValueError(
f"Unknown algorithm alias '{name}'. Supported algorithms: {sorted(_ALG_REGISTRY)}. "
"If you are adding a new algorithm, register it via "
"auto_round.algorithms.registry.register_algorithm()."
)
if canonical not in seen:
canonical_names.append(canonical)
seen.add(canonical)
return canonical_names
def get_algorithm_entry(name: str) -> AlgRegistryEntry:
_ensure_builtin_algorithms_registered()
canonical = resolve_algorithm_alias(name)
if canonical is None or canonical not in _ALG_REGISTRY:
raise KeyError(name)
return _ALG_REGISTRY[canonical]
def iter_algorithm_entries() -> list[AlgRegistryEntry]:
_ensure_builtin_algorithms_registered()
return list(_ALG_REGISTRY.values())
def resolve_alg_config(alias: str) -> object:
_ensure_builtin_algorithms_registered()
canonical = resolve_algorithm_alias(alias)
if canonical is None:
raise ValueError(
f"Unknown algorithm alias '{alias}'. Supported algorithms: {sorted(_ALG_REGISTRY)}. "
"If you are adding a new algorithm, register it via auto_round.algorithms.registry.register_algorithm()."
)
entry = _ALG_REGISTRY[canonical]
factory = entry.alias_factories.get(alias.strip().lower(), entry.config_factory)
if factory is None:
raise ValueError(f"Algorithm alias '{alias}' is registered but has no config factory.")
return factory()
def list_registered_algorithms() -> list[str]:
_ensure_builtin_algorithms_registered()
return sorted(_ALIAS_TO_NAME.keys())
def register_pipeline_member(config_cls: type):
def _decorator(member_cls: type[BaseAlgorithm]) -> type[BaseAlgorithm]:
_CONFIG_IMPL_REGISTRY[config_cls] = member_cls
return member_cls
return _decorator
def resolve_pipeline_member(config: object) -> type[BaseAlgorithm]:
_ensure_pipeline_members_registered()
config_cls = type(config)
for cls in config_cls.__mro__:
member_cls = _CONFIG_IMPL_REGISTRY.get(cls)
if member_cls is not None:
return member_cls
raise ValueError(f"Unknown algorithm config type {config_cls.__name__!r}.")
def pipeline_member_for_config_class(config_cls: type):
"""Return the pipeline member class for a config *class* (or ``None``).
Class-level counterpart of :func:`resolve_pipeline_member` (which needs an
instance). Used by the CLI to tell whether an algorithm is a terminal block
quantizer without constructing its config.
"""
_ensure_pipeline_members_registered()
for cls in config_cls.__mro__:
member_cls = _CONFIG_IMPL_REGISTRY.get(cls)
if member_cls is not None:
return member_cls
return None
def coerce_config_class(config: object, target_cls: type) -> object:
if type(config) is target_cls:
return config
new_config = copy.copy(config)
if hasattr(config, "scheme") and getattr(config, "scheme", None) is not None:
new_config.scheme = config.scheme.copy()
if hasattr(config, "_user_set_scheme_fields"):
new_config._user_set_scheme_fields = set(getattr(config, "_user_set_scheme_fields", set()))
new_config.__class__ = target_cls
return new_config
def normalize_algorithm_config(config: object) -> object:
from auto_round.algorithms.quantization.qad.config import QADConfig
from auto_round.algorithms.quantization.rtn.config import OptimizedRTNConfig, RTNConfig
from auto_round.algorithms.quantization.sign_round.config import AdamRoundConfig, SignRoundConfig, SignRoundV2Config
if type(config) in (SignRoundConfig, SignRoundV2Config, AdamRoundConfig) and getattr(config, "enable_qad", False):
defaults = QADConfig(
topk=getattr(config, "lfq_top_k", 32),
qad_optimizer="adamw" if getattr(config, "enable_adam", False) else getattr(config, "optimizer", None),
)
normalized = coerce_config_class(config, QADConfig)
for key, value in vars(defaults).items():
if not hasattr(normalized, key):
setattr(normalized, key, value)
normalized.optimizer = defaults.optimizer
return normalized
if type(config) is OptimizedRTNConfig and getattr(config, "disable_opt_rtn", False):
return coerce_config_class(config, RTNConfig)
if type(config) is RTNConfig and not getattr(config, "disable_opt_rtn", False):
return coerce_config_class(config, OptimizedRTNConfig)
if type(config) is SignRoundConfig:
if getattr(config, "enable_adam", False):
return coerce_config_class(config, AdamRoundConfig)
if getattr(config, "enable_alg_ext", False):
return coerce_config_class(config, SignRoundV2Config)
return config