chore: import upstream snapshot with attribution

vllm/model_executor/layers/quantization/inc/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from .inc import INCConfig
+
+__all__ = ["INCConfig"]

vllm/model_executor/layers/quantization/inc/config_parser.py

@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import regex as re
+
+from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
+
+if TYPE_CHECKING:
+    import torch
+
+    from .inc import INCConfig
+
+
+@dataclass(frozen=True)
+class INCLayerConfig:
+    bits: int
+    group_size: int
+    sym: bool
+    packing_format: str
+    backend: str
+    data_type: str
+    quantized: bool
+
+    @property
+    def is_gptq(self) -> bool:
+        return "gptq" in self.packing_format or "gptq" in self.backend
+
+    @property
+    def is_awq(self) -> bool:
+        return "awq" in self.packing_format or "awq" in self.backend
+
+    @property
+    def is_wna16_int(self) -> bool:
+        return self.data_type == "int" and self.quantized
+
+    @property
+    def is_mxfp4(self) -> bool:
+        return self.data_type == "mx_fp" and self.bits == 4
+
+    @property
+    def is_mxfp8(self) -> bool:
+        return self.data_type == "mx_fp" and self.bits == 8
+
+
+class INCConfigParser:
+    def __init__(self, config: "INCConfig") -> None:
+        self._config = config
+
+    def resolve(self, layer: "torch.nn.Module", layer_name: str) -> INCLayerConfig:
+        bits, group_size, sym = self._resolve_raw(layer, layer_name)
+        return INCLayerConfig(
+            bits=bits,
+            group_size=group_size,
+            sym=sym,
+            packing_format=self._config.packing_format,
+            backend=self._config.backend,
+            data_type=self._config.data_type,
+            quantized=bits < 16,
+        )
+
+    def get_layer_config(
+        self, layer: "torch.nn.Module", layer_name: str
+    ) -> tuple[int, int, bool]:
+        layer_config = self.resolve(layer, layer_name)
+        return layer_config.bits, layer_config.group_size, layer_config.sym
+
+    def _resolve_raw(
+        self, layer: "torch.nn.Module", layer_name: str
+    ) -> tuple[int, int, bool]:
+        REGEX_SPECIAL_CHARS = set(r"*+?^$()[]{}|\\")
+
+        def is_explicitly_configured(name: str) -> bool:
+            """Return True if *name* has an explicit entry in extra_config,
+            either via exact key match or via a regex pattern key."""
+            if not self._config.extra_config:
+                return False
+            if name in self._config.extra_config:
+                return True
+            for pattern in self._config.extra_config:
+                if not isinstance(pattern, str) or not any(
+                    c in REGEX_SPECIAL_CHARS for c in pattern
+                ):
+                    continue
+                try:
+                    if re.search(re.compile(pattern), name) is not None:
+                        return True
+                except re.error:
+                    continue
+            return False
+
+        def get_config(name: str, quantized: bool = True) -> tuple[int, int, bool]:
+            if not self._config.extra_config:
+                return (
+                    self._config.weight_bits if quantized else 16,
+                    self._config.group_size if quantized else -1,
+                    self._config.sym if quantized else True,
+                )
+
+            if name in self._config.extra_config:
+                cfg = self._config.extra_config[name]
+                return (
+                    cfg.get("bits", self._config.weight_bits if quantized else 16),
+                    cfg.get(
+                        "group_size",
+                        self._config.group_size if quantized else -1,
+                    ),
+                    cfg.get("sym", self._config.sym if quantized else True),
+                )
+
+            regex_special_chars = set(r"*+?^$()[]{}|\\")
+            for pattern, cfg in self._config.extra_config.items():
+                if not isinstance(pattern, str) or not any(
+                    c in regex_special_chars for c in pattern
+                ):
+                    continue
+
+                try:
+                    if re.search(re.compile(pattern), name) is not None:
+                        return (
+                            cfg.get(
+                                "bits",
+                                self._config.weight_bits if quantized else 16,
+                            ),
+                            cfg.get(
+                                "group_size",
+                                self._config.group_size if quantized else -1,
+                            ),
+                            cfg.get("sym", self._config.sym if quantized else True),
+                        )
+                except re.error:
+                    continue
+
+            return (
+                self._config.weight_bits if quantized else 16,
+                self._config.group_size if quantized else -1,
+                self._config.sym if quantized else True,
+            )
+
+        if self._config.extra_config and layer_name in self._config.extra_config:
+            return get_config(layer_name)
+
+        quantized = not isinstance(layer, ParallelLMHead)
+        if self._config.block_name_to_quantize:
+            quantized = any(
+                layer_name.startswith(name)
+                for name in self._config.block_name_to_quantize
+            )
+
+        if self._config.extra_config and "fusedmoe" in layer.__class__.__name__.lower():
+            moe_configs = [
+                get_config(name, quantized)
+                for name in self._config.extra_config
+                if name.startswith(layer_name)
+            ]
+            if moe_configs:
+                if len(set(moe_configs)) == 1:
+                    return moe_configs[0]
+                raise ValueError(
+                    f"Fused MoE layer '{layer_name}' requires "
+                    f"consistent quant config for all sub-layers"
+                )
+
+        if self._config.extra_config:
+            for fusion_key, sub_keys in self._config.packed_modules_mapping.items():
+                if fusion_key in layer_name and layer_name.count(fusion_key) == 1:
+                    sub_names = [
+                        layer_name.replace(fusion_key, sub_key) for sub_key in sub_keys
+                    ]
+                    # Only trigger if at least one sub_name is explicitly
+                    # configured in extra_config (via exact match or regex).
+                    # This prevents false matches when a short fusion_key
+                    # (e.g. "qkv") is merely a substring of a longer layer
+                    # name (e.g. "in_proj_qkvz") and none of the generated
+                    # sub_names are actually configured.
+                    if not any(is_explicitly_configured(n) for n in sub_names):
+                        continue
+                    sub_configs = [get_config(name, quantized) for name in sub_names]
+                    if len(set(sub_configs)) == 1:
+                        return sub_configs[0]
+                    raise ValueError(
+                        f"Fused module '{layer_name}' requires "
+                        f"consistent quant config for {sub_names}"
+                    )
+
+        return get_config(layer_name, quantized)

vllm/model_executor/layers/quantization/inc/inc.py

@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from fractions import Fraction
+from typing import TYPE_CHECKING, Any
+
+import torch
+
+from vllm.logger import init_logger
+from vllm.model_executor.layers.fused_moe import (
+    RoutedExperts,
+    UnquantizedFusedMoEMethod,
+)
+from vllm.model_executor.layers.linear import (
+    LinearBase,
+    UnquantizedLinearMethod,
+)
+from vllm.model_executor.layers.quantization import (
+    QuantizationConfig,
+    QuantizationMethods,
+)
+from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
+
+from .config_parser import INCConfigParser
+
+if TYPE_CHECKING:
+    from vllm.model_executor.models.utils import WeightsMapper
+
+logger = init_logger(__name__)
+
+
+class INCConfig(QuantizationConfig):
+    """Config class for Intel Neural Compressor (INC).
+    Repo: https://github.com/intel/neural-compressor
+    """
+
+    SUPPORTED_BITS = {2, 3, 4, 8}
+    SUPPORTED_DTYPES = {"int"}
+    SUPPORTED_FORMATS = {"auto_round:auto_gptq", "auto_round:auto_awq"}
+    SUPPORTED_BACKENDS = {
+        "auto",
+        "gptq",
+        "gptq:marlin",
+        "awq",
+        "awq:marlin",
+        "marlin",
+    }
+
+    def __init__(
+        self,
+        weight_bits: int,
+        group_size: int,
+        sym: bool = True,
+        packing_format: str = "auto_round:auto_gptq",
+        block_name_to_quantize: str | list[str] | None = None,
+        extra_config: dict[str, Any] | None = None,
+        data_type: str = "int",
+        backend: str = "auto",
+    ) -> None:
+        super().__init__()
+        if weight_bits not in self.SUPPORTED_BITS:
+            raise ValueError(
+                f"Unsupported weight_bits: {weight_bits}, "
+                f"currently only support {self.SUPPORTED_BITS}."
+            )
+        if data_type not in self.SUPPORTED_DTYPES:
+            raise ValueError(
+                f"Unsupported data_type: {data_type},"
+                f" currently only support  {self.SUPPORTED_DTYPES}."
+            )
+        if packing_format not in self.SUPPORTED_FORMATS:
+            raise ValueError(
+                f"Unsupported packing_format: {packing_format}, "
+                f"currently only support {self.SUPPORTED_FORMATS}."
+            )
+        if backend not in self.SUPPORTED_BACKENDS:
+            raise ValueError(
+                f"Unsupported backend: {backend},  "
+                f"currently only support {self.SUPPORTED_BACKENDS}."
+            )
+
+        self.weight_bits = weight_bits
+        self.group_size = group_size
+        self.sym = sym
+        self.packing_format = packing_format
+        self.block_name_to_quantize = (
+            block_name_to_quantize.split(",")
+            if isinstance(block_name_to_quantize, str)
+            else block_name_to_quantize
+        )
+        self.extra_config = extra_config
+        self.data_type = data_type
+        self.backend = backend
+        self.pack_factor = Fraction(32, weight_bits)
+        self.config_parser = INCConfigParser(self)
+
+    def __repr__(self) -> str:
+        return (
+            f"INCConfig(weight_bits={self.weight_bits}, "
+            f"group_size={self.group_size}, sym={self.sym})"
+        )
+
+    @classmethod
+    def get_name(cls) -> QuantizationMethods:
+        return "inc"
+
+    @classmethod
+    def get_supported_act_dtypes(cls) -> list[torch.dtype]:
+        return [torch.half, torch.bfloat16]
+
+    @classmethod
+    def get_min_capability(cls) -> int:
+        return 60
+
+    @classmethod
+    def get_config_filenames(cls) -> list[str]:
+        return ["quantization_config.json"]
+
+    @classmethod
+    def from_config(cls, config: dict[str, Any]) -> "INCConfig":
+        return cls(
+            weight_bits=cls.get_from_keys(config, ["bits"]),
+            group_size=cls.get_from_keys(config, ["group_size"]),
+            sym=cls.get_from_keys(config, ["sym"]),
+            packing_format=cls.get_from_keys_or(
+                config, ["packing_format"], "auto_round:auto_gptq"
+            ),
+            block_name_to_quantize=cls.get_from_keys_or(
+                config, ["block_name_to_quantize", "to_quant_block_names"], None
+            ),
+            extra_config=cls.get_from_keys_or(config, ["extra_config"], None),
+            data_type=cls.get_from_keys_or(config, ["data_type"], "int"),
+            backend=cls.get_from_keys_or(config, ["backend", "vllm_backend"], "auto"),
+        )
+
+    def get_layer_config(self, layer, layer_name: str):
+        return self.config_parser.get_layer_config(layer, layer_name)
+
+    def apply_vllm_mapper(self, hf_to_vllm_mapper: "WeightsMapper"):
+        if self.block_name_to_quantize is not None:
+            self.block_name_to_quantize = hf_to_vllm_mapper.apply_list(
+                self.block_name_to_quantize
+            )
+        if self.extra_config is not None:
+            self.extra_config = hf_to_vllm_mapper.apply_dict(self.extra_config)
+
+    def get_quant_method(self, layer: torch.nn.Module, prefix: str):
+        from .schemes.factory import resolve_scheme
+
+        # Match original: check model.-prefixed names for unquantized layers
+        if prefix and self.extra_config:
+            for layer_name in self.extra_config:
+                if (
+                    layer_name == prefix or layer_name == f"model.{prefix}"
+                ) and self.extra_config[layer_name].get("bits", 16) >= 16:
+                    if isinstance(layer, RoutedExperts):
+                        return UnquantizedFusedMoEMethod(layer.moe_config)
+                    return UnquantizedLinearMethod()
+
+        layer_config = self.config_parser.resolve(layer, prefix)
+        if not layer_config.quantized:
+            if isinstance(layer, (LinearBase, ParallelLMHead)):
+                return UnquantizedLinearMethod()
+            if isinstance(layer, RoutedExperts):
+                return UnquantizedFusedMoEMethod(layer.moe_config)
+            return None
+
+        logger.debug(
+            "[%s] Type: %s, Bits: %s, Group Size: %s, Sym: %s",
+            prefix,
+            layer.__class__.__name__,
+            layer_config.bits,
+            layer_config.group_size,
+            layer_config.sym,
+        )
+
+        scheme = resolve_scheme(layer_config)
+        if isinstance(layer, (LinearBase, ParallelLMHead)):
+            return scheme.get_linear_method(self, layer, prefix, layer_config)
+        if isinstance(layer, RoutedExperts):
+            return scheme.get_moe_method(self, layer, prefix, layer_config)
+        return None
+
+    @classmethod
+    def override_quantization_method(
+        cls, hf_quant_cfg, user_quant, hf_config=None
+    ) -> "QuantizationMethods | None":
+        """Override the `auto-round` method to `inc`."""
+        is_auto_round_format = hf_quant_cfg.get("quant_method", None) == "auto-round"
+        if is_auto_round_format:
+            return cls.get_name()
+        return None

vllm/model_executor/layers/quantization/inc/inc_linear.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import TYPE_CHECKING
+
+import torch
+
+from vllm.model_executor.layers.linear import LinearMethodBase
+
+if TYPE_CHECKING:
+    from .schemes.inc_scheme import INCLinearScheme
+
+
+class INCLinearMethod(LinearMethodBase):
+    def __init__(self, scheme: "INCLinearScheme") -> None:
+        self.scheme = scheme
+
+    def create_weights(
+        self,
+        layer: torch.nn.Module,
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        input_size: int,
+        output_size: int,
+        params_dtype: torch.dtype,
+        **extra_weight_attrs,
+    ):
+        return self.scheme.create_weights(
+            layer=layer,
+            input_size_per_partition=input_size_per_partition,
+            output_partition_sizes=output_partition_sizes,
+            input_size=input_size,
+            output_size=output_size,
+            params_dtype=params_dtype,
+            **extra_weight_attrs,
+        )
+
+    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
+        return self.scheme.process_weights_after_loading(layer)
+
+    def apply(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        return self.scheme.apply_weights(layer, x, bias)

vllm/model_executor/layers/quantization/inc/schemes/__init__.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from .factory import resolve_scheme
+from .inc_scheme import INCLinearScheme, INCScheme
+from .inc_wna16_scheme import INCWna16Scheme
+
+__all__ = [
+    "INCScheme",
+    "INCLinearScheme",
+    "INCWna16Scheme",
+    "resolve_scheme",
+]

vllm/model_executor/layers/quantization/inc/schemes/factory.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..config_parser import INCLayerConfig
+    from .inc_scheme import INCScheme
+
+
+def resolve_scheme(layer_config: "INCLayerConfig") -> "INCScheme":
+    from .inc_wna16_scheme import INCWna16Scheme
+
+    scheme_list: list[type[INCScheme]] = [
+        INCWna16Scheme,
+    ]
+
+    for scheme_cls in scheme_list:
+        if scheme_cls.can_handle(layer_config):
+            return scheme_cls()
+
+    raise NotImplementedError(f"No INC scheme found for layer config: {layer_config}")

vllm/model_executor/layers/quantization/inc/schemes/inc_ark_ops.py

@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from functools import lru_cache
+from typing import Any
+
+import torch
+
+from vllm.logger import init_logger
+from vllm.platforms import current_platform
+from vllm.utils.torch_utils import direct_register_custom_op
+
+logger = init_logger(__name__)
+
+_OPS_REGISTERED = False
+
+
+@lru_cache(maxsize=1)
+def get_ark_state() -> tuple[bool, str | None, Any | None, Any | None]:
+    """Return ARK availability, error details, cached module, and QuantLinear."""
+    try:
+        import auto_round_kernel as ark
+        from auto_round_kernel.qlinear import QuantLinear
+
+        logger.info("Successfully imported auto_round_kernel.")
+    except ImportError as error:
+        return False, str(error), None, None
+
+    if getattr(ark, "cpu_lib", None) is None and getattr(ark, "xpu_lib", None) is None:
+        return (
+            False,
+            "No ARK backend library is available.",
+            None,
+            None,
+        )
+
+    logger.info("Successfully loaded auto_round_kernel backend library.")
+    return True, None, ark, QuantLinear
+
+
+def _inc_ark_woq_linear_impl(
+    x: torch.Tensor,
+    qweight: torch.Tensor,
+    bias: torch.Tensor | None,
+    out_features: int,
+    in_features: int,
+    group_size: int,
+    compute_type: str,
+    weight_type: str,
+    scale_type: str,
+    asym: bool,
+) -> torch.Tensor:
+    ark = get_ark_state()[2]
+    assert ark is not None
+
+    return ark.woqgemm_linear(
+        x,
+        qweight,
+        bias,
+        out_features,
+        in_features,
+        group_size,
+        compute_type,
+        weight_type,
+        scale_type,
+        asym,
+    )
+
+
+def _inc_ark_woq_linear_fake(
+    x: torch.Tensor,
+    qweight: torch.Tensor,
+    bias: torch.Tensor | None,
+    out_features: int,
+    in_features: int,
+    group_size: int,
+    compute_type: str,
+    weight_type: str,
+    scale_type: str,
+    asym: bool,
+) -> torch.Tensor:
+    del qweight
+    del bias
+    del in_features
+    del group_size
+    del compute_type
+    del weight_type
+    del scale_type
+    del asym
+    return torch.empty(
+        (*x.shape[:-1], out_features),
+        dtype=x.dtype,
+        device=x.device,
+    )
+
+
+class ark_ops:
+    @staticmethod
+    def register_ops_once() -> None:
+        global _OPS_REGISTERED
+        if _OPS_REGISTERED:
+            return
+
+        is_available, error_str, _, _ = get_ark_state()
+        if not is_available:
+            logger.debug(
+                "Skip registering ark op because ARK is unavailable: %s",
+                error_str or "unknown error",
+            )
+            return
+
+        direct_register_custom_op(
+            op_name="inc_ark_woq_linear",
+            op_func=_inc_ark_woq_linear_impl,
+            fake_impl=_inc_ark_woq_linear_fake,
+            dispatch_key=current_platform.dispatch_key,
+        )
+        _OPS_REGISTERED = True
+
+
+ark_ops.register_ops_once()
+
+__all__ = ["get_ark_state"]

vllm/model_executor/layers/quantization/inc/schemes/inc_scheme.py

@@ -0,0 +1,104 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import torch
+
+    from vllm.model_executor.layers.fused_moe import FusedMoEMethodBase
+    from vllm.model_executor.layers.linear import LinearMethodBase
+    from vllm.model_executor.layers.quantization import QuantizationMethods
+
+    from ..config_parser import INCLayerConfig
+    from ..inc import INCConfig
+
+
+class INCScheme(ABC):
+    """One class per quant type. Single registration point for the factory.
+
+    Each subclass defines:
+      - can_handle(): when does this scheme apply?
+      - get_linear_method(): required — how to quantize Linear layers
+      - get_moe_method(): optional — how to quantize MoE layers
+      - get_kvcache_method(): optional — how to quantize KV cache
+
+    Schemes that don't support MoE/KVCache inherit the default raise.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def can_handle(layer_config: "INCLayerConfig") -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_linear_method(
+        self,
+        config: "INCConfig",
+        layer: "torch.nn.Module",
+        prefix: str,
+        layer_config: "INCLayerConfig",
+    ) -> "LinearMethodBase":
+        raise NotImplementedError
+
+    def get_moe_method(
+        self,
+        config: "INCConfig",
+        layer: "torch.nn.Module",
+        prefix: str,
+        layer_config: "INCLayerConfig",
+    ) -> "FusedMoEMethodBase | None":
+        """Optional. Override if this scheme supports MoE.
+        Default raises NotImplementedError."""
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support MoE layers. "
+            f"Layer config: {layer_config}"
+        )
+
+    def get_kvcache_method(
+        self,
+        config: "INCConfig",
+        layer: "torch.nn.Module",
+        prefix: str,
+        layer_config: "INCLayerConfig",
+    ) -> "QuantizationMethods":
+        """Optional. Override if this scheme supports KV cache quantization.
+        Default raises NotImplementedError."""
+        raise NotImplementedError(
+            f"{type(self).__name__} does not support KV cache quantization. "
+            f"Layer config: {layer_config}"
+        )
+
+
+class INCLinearScheme(ABC):
+    @classmethod
+    @abstractmethod
+    def get_min_capability(cls) -> int:
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_weights(
+        self,
+        layer: "torch.nn.Module",
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        input_size: int,
+        output_size: int,
+        params_dtype: "torch.dtype",
+        **extra_weight_attrs,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def process_weights_after_loading(self, layer: "torch.nn.Module") -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def apply_weights(
+        self,
+        layer: "torch.nn.Module",
+        x: "torch.Tensor",
+        bias: "torch.Tensor | None" = None,
+    ) -> "torch.Tensor":
+        raise NotImplementedError

vllm/model_executor/layers/quantization/inc/schemes/inc_wna16_linear.py

@@ -0,0 +1,463 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import TYPE_CHECKING, Any
+
+import torch
+from torch.nn.parameter import Parameter
+
+from vllm.model_executor.layers.quantization.auto_awq import AutoAWQConfig
+from vllm.model_executor.layers.quantization.auto_gptq import AutoGPTQConfig
+from vllm.model_executor.layers.quantization.utils.marlin_utils import (
+    check_marlin_supported,
+)
+from vllm.model_executor.parameter import (
+    GroupQuantScaleParameter,
+    PackedvLLMParameter,
+    RowvLLMParameter,
+)
+from vllm.scalar_type import scalar_types
+
+from .inc_scheme import INCLinearScheme
+
+if TYPE_CHECKING:
+    from ..config_parser import INCLayerConfig
+
+
+class INCWNA16LinearScheme(INCLinearScheme):
+    def __init__(self, layer_config: "INCLayerConfig") -> None:
+        self.layer_config = layer_config
+        self.inner_method = self._build_inner_method()
+
+    @classmethod
+    def get_min_capability(cls) -> int:
+        return 60
+
+    def _build_inner_method(self):
+        if self.layer_config.is_gptq:
+            return self._build_gptq_method()
+        if self.layer_config.is_awq:
+            return self._build_awq_method()
+        raise NotImplementedError(
+            f"WNA16 linear scheme does not support {self.layer_config}"
+        )
+
+    def _build_gptq_method(self):
+        gptq_type_map = {
+            (4, True): scalar_types.uint4b8,
+            (8, True): scalar_types.uint8b128,
+        }
+        use_marlin = (
+            self.layer_config.backend == "auto" or "marlin" in self.layer_config.backend
+        ) and (self.layer_config.bits, self.layer_config.sym) in gptq_type_map
+        if use_marlin:
+            use_marlin = check_marlin_supported(
+                gptq_type_map[(self.layer_config.bits, self.layer_config.sym)],
+                self.layer_config.group_size,
+                has_zp=not self.layer_config.sym,
+            )
+
+        if use_marlin:
+            from vllm.model_executor.layers.quantization.auto_gptq import (
+                AutoGPTQLinearMethod,
+            )
+
+            return AutoGPTQLinearMethod(
+                AutoGPTQConfig(
+                    weight_bits=self.layer_config.bits,
+                    group_size=self.layer_config.group_size,
+                    desc_act=False,
+                    is_sym=self.layer_config.sym,
+                    lm_head_quantized=False,
+                    dynamic={},
+                    full_config={},
+                )
+            )
+
+        raise NotImplementedError(
+            f"INC quantization with bits={self.layer_config.bits}, "
+            f"sym={self.layer_config.sym} is not supported. "
+            "Only 4-bit and 8-bit symmetric quantization is supported "
+            "with Marlin kernels."
+        )
+
+    def _build_awq_method(self):
+        awq_type_map = {
+            4: scalar_types.uint4,
+            8: scalar_types.uint8,
+        }
+        use_marlin = (
+            self.layer_config.backend == "auto" or "marlin" in self.layer_config.backend
+        ) and self.layer_config.bits in awq_type_map
+        if use_marlin:
+            use_marlin = check_marlin_supported(
+                awq_type_map[self.layer_config.bits],
+                self.layer_config.group_size,
+                not self.layer_config.sym,
+            )
+
+        if use_marlin:
+            from vllm.model_executor.layers.quantization.auto_awq import (
+                AutoAWQMarlinLinearMethod,
+            )
+
+            return AutoAWQMarlinLinearMethod(
+                AutoAWQConfig(
+                    weight_bits=self.layer_config.bits,
+                    group_size=self.layer_config.group_size,
+                    zero_point=not self.layer_config.sym,
+                    lm_head_quantized=False,
+                    modules_to_not_convert=[],
+                    full_config={},
+                )
+            )
+
+        from vllm.model_executor.layers.quantization.auto_awq import (
+            AutoAWQLinearMethod,
+        )
+
+        return AutoAWQLinearMethod(
+            AutoAWQConfig(
+                weight_bits=self.layer_config.bits,
+                group_size=self.layer_config.group_size,
+                zero_point=not self.layer_config.sym,
+                lm_head_quantized=False,
+            )
+        )
+
+    def create_weights(
+        self,
+        layer: "torch.nn.Module",
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        input_size: int,
+        output_size: int,
+        params_dtype: "torch.dtype",
+        **extra_weight_attrs,
+    ) -> None:
+        return self.inner_method.create_weights(
+            layer=layer,
+            input_size_per_partition=input_size_per_partition,
+            output_partition_sizes=output_partition_sizes,
+            input_size=input_size,
+            output_size=output_size,
+            params_dtype=params_dtype,
+            **extra_weight_attrs,
+        )
+
+    def process_weights_after_loading(self, layer: "torch.nn.Module") -> None:
+        return self.inner_method.process_weights_after_loading(layer)
+
+    def apply_weights(
+        self,
+        layer: "torch.nn.Module",
+        x: "torch.Tensor",
+        bias: "torch.Tensor | None" = None,
+    ) -> "torch.Tensor":
+        return self.inner_method.apply(layer, x, bias)
+
+
+class INCXPULinearBase(INCLinearScheme):
+    # AWQ packs nibbles within each int32 in the order [0, 2, 4, 6, 1, 3, 5, 7];
+    # this permutation undoes that ordering so values can be repacked in
+    # standard sequential (GPTQ) order.
+    _REVERSE_AWQ_PACK_ORDER = [0, 4, 1, 5, 2, 6, 3, 7]
+
+    def __init__(self, layer_config: "INCLayerConfig") -> None:
+        self.weight_bits = layer_config.bits
+        self.group_size = layer_config.group_size
+        self.sym = layer_config.sym
+        self.pack_factor = 32 // self.weight_bits
+        self.is_awq_packed = layer_config.is_awq
+
+    @classmethod
+    def get_min_capability(cls) -> int:
+        return 0
+
+    def _create_inc_weights(
+        self,
+        layer: torch.nn.Module,
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        params_dtype: torch.dtype,
+        weight_loader: Any,
+    ) -> None:
+        output_size_per_partition = sum(output_partition_sizes)
+        scales_and_zp_size = input_size_per_partition // self.group_size
+
+        if self.is_awq_packed:
+            # AWQ: qweight [in, out // pack_factor] packed along output dim
+            qweight = PackedvLLMParameter(
+                data=torch.empty(
+                    input_size_per_partition,
+                    output_size_per_partition // self.pack_factor,
+                    dtype=torch.int32,
+                ),
+                input_dim=0,
+                output_dim=1,
+                packed_dim=1,
+                packed_factor=self.pack_factor,
+                weight_loader=weight_loader,
+            )
+        else:
+            # GPTQ: qweight [in // pack_factor, out] packed along input dim
+            qweight = PackedvLLMParameter(
+                data=torch.empty(
+                    input_size_per_partition // self.pack_factor,
+                    output_size_per_partition,
+                    dtype=torch.int32,
+                ),
+                input_dim=0,
+                output_dim=1,
+                packed_dim=0,
+                packed_factor=self.pack_factor,
+                weight_loader=weight_loader,
+            )
+        scales = GroupQuantScaleParameter(
+            data=torch.empty(
+                scales_and_zp_size,
+                output_size_per_partition,
+                dtype=params_dtype,
+            ),
+            input_dim=0,
+            output_dim=1,
+            weight_loader=weight_loader,
+        )
+        # Both AWQ and GPTQ checkpoints store qzeros with this shape; for
+        # symmetric quantization the values are ignored downstream.
+        qzeros = PackedvLLMParameter(
+            data=torch.empty(
+                scales_and_zp_size,
+                output_size_per_partition // self.pack_factor,
+                dtype=torch.int32,
+            ),
+            input_dim=0,
+            output_dim=1,
+            packed_dim=1,
+            packed_factor=self.pack_factor,
+            weight_loader=weight_loader,
+        )
+
+        layer.register_parameter("qweight", qweight)
+        layer.register_parameter("scales", scales)
+        layer.register_parameter("qzeros", qzeros)
+
+        g_idx = RowvLLMParameter(
+            data=torch.tensor(
+                [i // self.group_size for i in range(input_size_per_partition)],
+                dtype=torch.int32,
+            ),
+            input_dim=0,
+            weight_loader=weight_loader,
+        )
+        layer.register_parameter("g_idx", g_idx)
+
+    def _convert_awq_qweight_to_gptq(self, qw: torch.Tensor) -> torch.Tensor:
+        """Convert AWQ qweight [K, N // pf] to GPTQ qweight [K // pf, N].
+
+        AWQ packs along the output dim with a non-standard nibble order; GPTQ
+        packs along the input dim with sequential nibble order. The conversion
+        is lossless — it only reshuffles bits.
+        """
+        size_bits = self.weight_bits
+        pack_factor = self.pack_factor
+        mask = (1 << size_bits) - 1
+        device = qw.device
+        reverse_order = torch.tensor(
+            self._REVERSE_AWQ_PACK_ORDER, dtype=torch.long, device=device
+        )
+        shifts = torch.arange(0, 32, size_bits, dtype=torch.int32, device=device)
+
+        K, N_packed = qw.shape
+        N = N_packed * pack_factor
+
+        # Unpack int32 → individual values, fix AWQ nibble ordering
+        unpacked = (qw.unsqueeze(-1) >> shifts) & mask  # (K, N_packed, pf)
+        unpacked = unpacked[:, :, reverse_order]
+        unpacked = unpacked.reshape(K, N)  # (K, N)
+
+        # Repack along input dim (dim 0) in sequential nibble order
+        unpacked = unpacked.reshape(K // pack_factor, pack_factor, N)
+        new_qw = (unpacked.to(torch.int32) << shifts[None, :, None]).sum(
+            dim=1, dtype=torch.int32
+        )
+        return new_qw.contiguous()
+
+    def create_weights(
+        self,
+        layer: torch.nn.Module,
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        input_size: int,
+        output_size: int,
+        params_dtype: torch.dtype,
+        **extra_weight_attrs,
+    ) -> None:
+        del input_size, output_size
+        self._create_inc_weights(
+            layer=layer,
+            input_size_per_partition=input_size_per_partition,
+            output_partition_sizes=output_partition_sizes,
+            params_dtype=params_dtype,
+            weight_loader=extra_weight_attrs.get("weight_loader"),
+        )
+
+
+class INCXPULinearMethod(INCXPULinearBase):
+    """XPU linear method for INC w4a16 quantization (symmetric only).
+
+    Supports both GPTQ-packed (``auto_round:auto_gptq``) and AWQ-packed
+    (``auto_round:auto_awq``) AutoRound checkpoints. AWQ-packed qweights are
+    losslessly repacked into the GPTQ-style nibble layout during
+    ``process_weights_after_loading``, before the final oneDNN "NT" transpose
+    that ``torch.ops._xpu_C.int4_gemm_w4a16`` expects.
+    """
+
+    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
+        device = layer.qweight.data.device
+
+        qweight_data = layer.qweight.data
+        if self.is_awq_packed:
+            # Lossless repack: AWQ [K, N // pf] → GPTQ [K // pf, N]
+            qweight_data = self._convert_awq_qweight_to_gptq(qweight_data)
+
+        qweight_ct = qweight_data.t().contiguous()
+        layer.qweight = Parameter(qweight_ct.t(), requires_grad=False)
+        layer.scales = Parameter(layer.scales.data, requires_grad=False)
+        layer.qzeros = Parameter(
+            torch.tensor([8], dtype=torch.int8, device=device),
+            requires_grad=False,
+        )
+
+    def apply_weights(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        out_shape = x.shape[:-1] + (layer.qweight.shape[1],)
+        reshaped_x = x.reshape(-1, x.shape[-1])
+        out = torch.ops._xpu_C.int4_gemm_w4a16(
+            reshaped_x,
+            layer.qweight,
+            bias,
+            layer.scales,
+            layer.qzeros,
+            self.group_size,
+            None,
+        )
+        return out.reshape(out_shape)
+
+
+class INCARKLinearMethod(INCXPULinearBase):
+    def __init__(self, layer_config: "INCLayerConfig") -> None:
+        super().__init__(layer_config)
+
+        from .inc_ark_ops import get_ark_state
+
+        is_available, error_str, _, quant_linear_cls = get_ark_state()
+        if not is_available or quant_linear_cls is None:
+            reason = error_str or "unknown error"
+            raise ImportError(f"Failed to import auto_round_kernel. {reason}")
+
+        self.quant_linear_cls = quant_linear_cls
+
+    def create_weights(
+        self,
+        layer: torch.nn.Module,
+        input_size_per_partition: int,
+        output_partition_sizes: list[int],
+        input_size: int,
+        output_size: int,
+        params_dtype: torch.dtype,
+        **extra_weight_attrs,
+    ) -> None:
+        super().create_weights(
+            layer=layer,
+            input_size_per_partition=input_size_per_partition,
+            output_partition_sizes=output_partition_sizes,
+            input_size=input_size,
+            output_size=output_size,
+            params_dtype=params_dtype,
+            **extra_weight_attrs,
+        )
+        layer.in_features = input_size_per_partition
+        layer.out_features = sum(output_partition_sizes)
+        layer.params_dtype = params_dtype
+
+    def process_weights_after_loading(self, layer: torch.nn.Module) -> None:
+        if hasattr(layer, "input_size_per_partition"):
+            in_features = layer.input_size_per_partition
+        elif hasattr(layer, "input_size"):
+            in_features = layer.input_size
+        else:
+            raise AttributeError("Cannot determine in_features for layer.")
+
+        if hasattr(layer, "output_partition_sizes"):
+            out_features = sum(layer.output_partition_sizes)
+        elif hasattr(layer, "output_size_per_partition"):
+            out_features = layer.output_size_per_partition
+        elif hasattr(layer, "output_size"):
+            out_features = layer.output_size
+        else:
+            out_features = layer.scales.shape[-1]
+
+        ark_linear = self.quant_linear_cls(
+            bits=self.weight_bits,
+            group_size=self.group_size,
+            sym=self.sym,
+            in_features=in_features,
+            out_features=out_features,
+            bias=layer.bias is not None,
+            weight_dtype=layer.params_dtype,
+        )
+        ark_linear.to(layer.qweight.device)
+
+        with torch.no_grad():
+            qweight_src = layer.qweight.detach()
+            if self.is_awq_packed:
+                # ARK consumes GPTQ-style packed nibbles; convert AWQ losslessly.
+                qweight_src = self._convert_awq_qweight_to_gptq(qweight_src)
+            ark_linear.qweight.copy_(qweight_src)
+            if hasattr(layer, "qzeros") and layer.qzeros is not None:
+                ark_linear.qzeros.copy_(layer.qzeros.detach())
+            else:
+                ark_linear.qzeros = None
+            ark_linear.scales.copy_(layer.scales.detach())
+            if hasattr(layer, "bias") and layer.bias is not None:
+                ark_linear.bias.copy_(layer.bias.detach())
+
+        ark_linear.post_init()
+
+        layer.qweight = Parameter(ark_linear.qweight.detach(), requires_grad=False)
+        layer.ark_bias = ark_linear.bias
+        layer.ark_compute_type = ark_linear.cdt
+        layer.ark_weight_type = ark_linear.wdt
+        layer.ark_scale_type = ark_linear.sdt
+
+        if hasattr(layer, "qzeros"):
+            del layer.qzeros
+        del layer.scales
+
+    def apply_weights(
+        self,
+        layer: torch.nn.Module,
+        x: torch.Tensor,
+        bias: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        return torch.ops.vllm.inc_ark_woq_linear.default(
+            x,
+            layer.qweight,
+            layer.ark_bias,
+            layer.out_features,
+            layer.in_features,
+            self.group_size,
+            layer.ark_compute_type,
+            layer.ark_weight_type,
+            layer.ark_scale_type,
+            not self.sym,
+        )
+
+
+class INCXPUW4A16LinearScheme(INCXPULinearMethod):
+    pass

vllm/model_executor/layers/quantization/inc/schemes/inc_wna16_scheme.py

@@ -0,0 +1,201 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import TYPE_CHECKING
+
+from vllm.logger import init_logger
+from vllm.model_executor.layers.quantization.auto_awq import AutoAWQConfig
+from vllm.model_executor.layers.quantization.auto_gptq import AutoGPTQConfig
+from vllm.platforms import current_platform
+from vllm.scalar_type import scalar_types
+
+from ..inc_linear import INCLinearMethod
+from .inc_scheme import INCScheme
+
+if TYPE_CHECKING:
+    import torch
+
+    from ..config_parser import INCLayerConfig
+    from ..inc import INCConfig
+
+logger = init_logger(__name__)
+
+
+class INCWna16Scheme(INCScheme):
+    @staticmethod
+    def can_handle(layer_config: "INCLayerConfig") -> bool:
+        return layer_config.is_wna16_int
+
+    def get_linear_method(
+        self,
+        config: "INCConfig",
+        layer: "torch.nn.Module",
+        prefix: str,
+        layer_config: "INCLayerConfig",
+    ):
+        del config, layer
+        if current_platform.is_xpu():
+            if layer_config.bits == 4 and layer_config.sym:
+                from .inc_ark_ops import get_ark_state
+                from .inc_wna16_linear import (
+                    INCARKLinearMethod,
+                    INCXPULinearMethod,
+                )
+
+                is_ark_available, ark_error, _, _ = get_ark_state()
+                if is_ark_available:
+                    return INCLinearMethod(INCARKLinearMethod(layer_config))
+
+                logger.debug(
+                    "ARK backend is unavailable for layer %s; "
+                    "falling back to the default XPU INC path. Error: %s",
+                    prefix,
+                    ark_error or "unknown error",
+                )
+                return INCLinearMethod(INCXPULinearMethod(layer_config))
+            raise NotImplementedError(f"INC on XPU: unsupported config {layer_config}")
+
+        if current_platform.is_cpu() and layer_config.is_gptq:
+            if layer_config.bits == 4 and layer_config.sym:
+                from .inc_ark_ops import get_ark_state
+                from .inc_wna16_linear import (
+                    INCARKLinearMethod,
+                    INCWNA16LinearScheme,
+                )
+
+                is_ark_available, ark_error, _, _ = get_ark_state()
+                if is_ark_available:
+                    return INCLinearMethod(INCARKLinearMethod(layer_config))
+
+                logger.debug(
+                    "ARK backend is unavailable for layer %s; "
+                    "falling back to the default CPU INC path. Error: %s",
+                    prefix,
+                    ark_error or "unknown error",
+                )
+                return INCLinearMethod(INCWNA16LinearScheme(layer_config))
+            raise NotImplementedError(f"INC on CPU: unsupported config {layer_config}")
+
+        from .inc_wna16_linear import INCWNA16LinearScheme
+
+        return INCLinearMethod(INCWNA16LinearScheme(layer_config))
+
+    def get_moe_method(
+        self,
+        config: "INCConfig",
+        layer: "torch.nn.Module",
+        prefix: str,
+        layer_config: "INCLayerConfig",
+    ):
+        del config, prefix
+        # XPU and CPU do not support MoE quantization yet
+        if current_platform.is_xpu() or current_platform.is_cpu():
+            from vllm.model_executor.layers.fused_moe import (
+                UnquantizedFusedMoEMethod,
+            )
+
+            return UnquantizedFusedMoEMethod(layer.moe_config)
+        if layer_config.is_gptq:
+            return _resolve_gptq_moe(layer, layer_config)
+        if layer_config.is_awq:
+            return _resolve_awq_moe(layer, layer_config)
+        raise NotImplementedError(f"WNA16 MoE does not support config {layer_config}")
+
+
+def _resolve_gptq_moe(layer: "torch.nn.Module", layer_config: "INCLayerConfig"):
+    from vllm.model_executor.layers.quantization.auto_gptq import (
+        AutoGPTQMoEMethod,
+    )
+    from vllm.model_executor.layers.quantization.moe_wna16 import (
+        MoeWNA16Config,
+        MoeWNA16Method,
+    )
+    from vllm.model_executor.layers.quantization.utils.marlin_utils import (
+        check_marlin_supported,
+        check_moe_marlin_supports_layer,
+    )
+
+    gptq_type_map = {
+        (4, True): scalar_types.uint4b8,
+        (8, True): scalar_types.uint8b128,
+    }
+    use_marlin = (layer_config.bits, layer_config.sym) in gptq_type_map
+    if use_marlin:
+        use_marlin = check_marlin_supported(
+            gptq_type_map[(layer_config.bits, layer_config.sym)],
+            layer_config.group_size,
+            has_zp=not layer_config.sym,
+        ) and check_moe_marlin_supports_layer(layer, layer_config.group_size)
+
+    if use_marlin:
+        return AutoGPTQMoEMethod(
+            AutoGPTQConfig(
+                weight_bits=layer_config.bits,
+                group_size=layer_config.group_size,
+                desc_act=False,
+                is_sym=layer_config.sym,
+                lm_head_quantized=False,
+                dynamic={},
+                full_config={},
+            ),
+            layer.moe_config,
+        )
+
+    moe_config = MoeWNA16Config.from_config(
+        {
+            "quant_method": "gptq",
+            "bits": layer_config.bits,
+            "group_size": layer_config.group_size,
+            "sym": layer_config.sym,
+            "lm_head": False,
+        }
+    )
+    return MoeWNA16Method(moe_config, layer.moe_config)
+
+
+def _resolve_awq_moe(layer: "torch.nn.Module", layer_config: "INCLayerConfig"):
+    from vllm.model_executor.layers.quantization.auto_awq import AutoAWQMoEMethod
+    from vllm.model_executor.layers.quantization.moe_wna16 import (
+        MoeWNA16Config,
+        MoeWNA16Method,
+    )
+    from vllm.model_executor.layers.quantization.utils.marlin_utils import (
+        check_marlin_supported,
+        check_moe_marlin_supports_layer,
+    )
+
+    awq_type_map = {
+        4: scalar_types.uint4,
+        8: scalar_types.uint8,
+    }
+    use_marlin = layer_config.bits in awq_type_map
+    if use_marlin:
+        use_marlin = check_marlin_supported(
+            awq_type_map[layer_config.bits],
+            layer_config.group_size,
+            not layer_config.sym,
+        ) and check_moe_marlin_supports_layer(layer, layer_config.group_size)
+
+    if use_marlin:
+        return AutoAWQMoEMethod(
+            AutoAWQConfig(
+                weight_bits=layer_config.bits,
+                group_size=layer_config.group_size,
+                zero_point=not layer_config.sym,
+                lm_head_quantized=False,
+                modules_to_not_convert=[],
+                full_config={},
+            ),
+            layer.moe_config,
+        )
+
+    moe_config = MoeWNA16Config.from_config(
+        {
+            "quant_method": "awq",
+            "bits": layer_config.bits,
+            "group_size": layer_config.group_size,
+            "zero_point": not layer_config.sym,
+            "lm_head": False,
+        }
+    )
+    return MoeWNA16Method(moe_config, layer.moe_config)