EngineX/xc-llm-ascend
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[Feat] 310p support MoE W8A8 quantizaition (#6641)

Browse Source 
### What this PR does / why we need it?
This PR introduces support for W8A8 dynamic quantization for
Mixture-of-Experts (MoE) models on Ascend 310P devices. This is achieved
by:
- Implementing a new quantization scheme
`AscendW8A8DynamicFusedMoEMethod310`.
- Adding a unified MLP implementation (`unified_apply_mlp`) for 310P
that handles both quantized and unquantized paths.
- Refactoring the MoE and quantization configuration logic to correctly
route to the new 310P-specific implementations.
- Adding new e2e and unit tests to verify the functionality of MoE W8A8
quantization.

### Does this PR introduce _any_ user-facing change?
No

### How was this patch tested?
- Added a new e2e test `test_qwen3_moe_tp2_w8a8` to test MoE W8A8
quantization in a multi-card setup.
- Added several new unit tests for the 310P-specific MoE components,
including `experts_selector`, `fused_moe`, `moe_comm_method`, `moe_mlp`,
and the new `w8a8_dynamic` quantization method.

- vLLM version: v0.15.0
- vLLM main:
d7e17aaacd

---------

Signed-off-by: pu-zhe <zpuaa@outlook.com>
This commit is contained in:
pu-zhe
2026-02-10 17:17:44 +08:00
committed by GitHub
parent 1eb07986bf
commit 02886e2641
15 changed files with 695 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
vllm_ascend/_310p/quantization/methods/__init__.py
View File

@@ -15,8 +15,7 @@
# This file is a part of the vllm-ascend project.
#
from . import w8a8_static # noqa: F401
# Future extensions:
# from . import w8a8_dynamic # noqa: F401
# from . import w4a16 # noqa: F401
from . import (
w8a8_dynamic, # noqa: F401
w8a8_static, # noqa: F401
)

149
vllm_ascend/_310p/quantization/methods/w8a8_dynamic.py Normal file
View File

@@ -0,0 +1,149 @@
#
# Copyright (c) 2026 Huawei Technologies Co., Ltd. All Rights Reserved.
#
# 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.
# This file is a part of the vllm-ascend project.
#
from collections.abc import Callable
from typing import Any
import torch
from vllm.config import get_current_vllm_config
from vllm.distributed import get_ep_group
from vllm.forward_context import get_forward_context
from vllm_ascend._310p.fused_moe.experts_selector import select_experts
from vllm_ascend.ops.fused_moe.experts_selector import zero_experts_compute
from vllm_ascend.quantization.methods.base import AscendMoEScheme, QuantType
from .registry import register_scheme
@register_scheme("W8A8_DYNAMIC", "moe")
class AscendW8A8DynamicFusedMoEMethod310(AscendMoEScheme):
"""310P-only FusedMoE method for Ascend W8A8_DYNAMIC.
Notes:
- This scheme is discovered via 310P local registry.
"""
# Declare the quantization type for this scheme
quant_type: QuantType = QuantType.W8A8
def __init__(self):
self.ep_group = get_ep_group()
vllm_config = get_current_vllm_config()
self.in_dtype = vllm_config.model_config.dtype
def get_weight(
self, num_experts: int, intermediate_size_per_partition: int, hidden_sizes: int, params_dtype: torch.dtype
) -> dict[str, Any]:
param_dict = {}
# Fused gate_up_proj (column parallel)
param_dict["w13_weight"] = torch.empty(
num_experts, 2 * intermediate_size_per_partition, hidden_sizes, dtype=torch.int8
)
# down_proj (row parallel)
param_dict["w2_weight"] = torch.empty(
num_experts, hidden_sizes, intermediate_size_per_partition, dtype=torch.int8
)
return param_dict
def get_dynamic_quant_param(
self, num_experts: int, intermediate_size_per_partition: int, hidden_sizes: int, params_dtype: torch.dtype
) -> dict[str, Any]:
param_dict = {}
param_dict["w13_weight_scale"] = torch.empty(
num_experts, 2 * intermediate_size_per_partition, 1, dtype=torch.float32
)
param_dict["w13_weight_offset"] = torch.empty(
num_experts, 2 * intermediate_size_per_partition, 1, dtype=params_dtype
)
param_dict["w2_weight_scale"] = torch.empty(num_experts, hidden_sizes, 1, dtype=torch.float32)
param_dict["w2_weight_offset"] = torch.empty(num_experts, hidden_sizes, 1, dtype=params_dtype)
return param_dict
def apply(
self,
layer: torch.nn.Module,
x: torch.Tensor,
router_logits: torch.Tensor,
top_k: int,
renormalize: bool,
use_grouped_topk: bool = False,
global_num_experts: int = -1,
expert_map: torch.Tensor | None = None,
topk_group: int | None = None,
num_expert_group: int | None = None,
custom_routing_function: Callable | None = None,
scoring_func: str = "softmax",
routed_scaling_factor: float = 1.0,
e_score_correction_bias: torch.Tensor | None = None,
is_prefill: bool = True,
enable_force_load_balance: bool = False,
log2phy: torch.Tensor | None = None,
global_redundant_expert_num: int = 0,
pertoken_scale: Any | None = None,
**kwargs,
) -> torch.Tensor:
zero_expert_num = getattr(layer, "zero_expert_num", 0)
zero_expert_type = getattr(layer, "zero_expert_type", None)
topk_weights, topk_ids = select_experts(
hidden_states=x,
router_logits=router_logits,
top_k=top_k,
use_grouped_topk=use_grouped_topk,
renormalize=renormalize,
topk_group=topk_group,
num_expert_group=num_expert_group,
custom_routing_function=custom_routing_function,
scoring_func=scoring_func,
e_score_correction_bias=e_score_correction_bias,
global_num_experts=global_num_experts,
)
if zero_expert_num > 0 and zero_expert_type is not None:
topk_ids, topk_weights, zero_expert_result = zero_experts_compute(
expert_indices=topk_ids,
expert_scales=topk_weights,
num_experts=global_num_experts,
zero_expert_type=zero_expert_type,
hidden_states=x,
)
topk_weights = topk_weights.to(self.in_dtype)
moe_comm_method = get_forward_context().moe_comm_method
final_hidden_states = moe_comm_method.fused_experts(
hidden_states=x,
w1=layer.w13_weight,
w1_scale=layer.w13_weight_scale,
w2=layer.w2_weight,
w2_scale=layer.w2_weight_scale,
topk_weights=topk_weights,
topk_ids=topk_ids,
expert_map=expert_map,
use_int8_w8a8=True,
)
if zero_expert_num > 0 and zero_expert_type is not None:
final_hidden_states += zero_expert_result
return final_hidden_states
def process_weights_after_loading(self, layer):
layer.w13_weight_scale.data = layer.w13_weight_scale.data.view(layer.w13_weight_scale.data.shape[0], -1)
layer.w13_weight_offset.data = layer.w13_weight_offset.data.view(layer.w13_weight_offset.data.shape[0], -1)
layer.w2_weight_scale.data = layer.w2_weight_scale.data.view(layer.w2_weight_scale.data.shape[0], -1)
layer.w2_weight_offset.data = layer.w2_weight_offset.data.view(layer.w2_weight_offset.data.shape[0], -1)

8
vllm_ascend/_310p/quantization/methods/w8a8_static.py
View File

@@ -50,13 +50,7 @@ class AscendW8A8LinearMethod310(AscendLinearScheme):
def get_perchannel_param(self, output_size: int, params_dtype: torch.dtype) -> dict[str, Any]:
params: dict[str, Any] = {}
params["quant_bias"] = torch.empty(output_size, dtype=torch.int32)
# NOTE: keep identical to your current working behavior.
if params_dtype == torch.bfloat16:
params["deq_scale"] = torch.empty(output_size, dtype=torch.float32)
else:
params["deq_scale"] = torch.empty(output_size, dtype=torch.int64)
params["deq_scale"] = torch.empty(output_size, dtype=torch.int64)
params["weight_scale"] = torch.empty(output_size, 1, dtype=params_dtype)
params["weight_offset"] = torch.empty(output_size, 1, dtype=params_dtype)
return params

94
vllm_ascend/_310p/quantization/modelslim_config.py
View File

@@ -31,14 +31,13 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (
VocabParallelEmbedding,
)
# Important: trigger 310P method registrations (register into 310P-local registry)
from vllm_ascend._310p.quantization import methods as _methods_310p # noqa: F401
from vllm_ascend._310p.quantization.methods.registry import get_scheme_class as get_scheme_class_310p
from vllm_ascend.quantization.method_adapters import (
AscendLinearMethod,
from vllm_ascend._310p.quantization.methods.registry import (
get_scheme_class,
)
from vllm_ascend.quantization.method_adapters import AscendFusedMoEMethod, AscendLinearMethod
from vllm_ascend.quantization.modelslim_config import (
AscendModelSlimConfig,
get_quant_type_for_layer,
packed_modules_model_mapping,
)
from vllm_ascend.utils import ASCEND_QUANTIZATION_METHOD
@@ -47,31 +46,34 @@ logger = init_logger(__name__)
def create_scheme_for_layer(
cfg: AscendModelSlimConfig,
quant_description: dict[str, Any],
prefix: str,
layer_type: str,
packed_modules_mapping: dict[str, Any] | None = None,
):
"""Create 310P quant scheme (mainline-like).
"""Create a quantization scheme instance for a layer.
- If quant_type cannot be determined: raise ValueError
- If quant_type is determined but not supported on 310P: raise NotImplementedError
Args:
quant_description: The quantization description dictionary.
prefix: The layer prefix.
layer_type: The type of layer ("linear", "moe", "attention").
packed_modules_mapping: Mapping for packed/fused modules.
Returns:
An instance of the appropriate quantization scheme class.
"""
logger.info_once("Using 310P ModelSlim Quantization routing.")
logger.info_once("Using the vLLM Ascend modelslim Quantization now!")
quant_type = get_quant_type_for_layer(quant_description, prefix, layer_type, packed_modules_mapping)
if layer_type != "linear":
raise NotImplementedError(f"310P quantization: layer_type={layer_type} is not supported yet (TODO).")
quant_type = cfg._get_linear_quant_type(prefix)
if quant_type is None:
raise ValueError(f"310P quantization: could not determine quant_type for layer={prefix}.")
raise ValueError(f"Could not determine quantization type for layer {prefix}.")
scheme_cls = get_scheme_class_310p(quant_type, "linear")
if scheme_cls is None:
raise NotImplementedError(f"310P quantization: quant_type={quant_type} for linear is not supported yet (TODO).")
return scheme_cls()
# Use registry to get scheme class
scheme_cls = get_scheme_class(quant_type, layer_type)
if scheme_cls is not None:
return scheme_cls()
else:
raise NotImplementedError(f"Currently, vLLM Ascend doesn't support {quant_type} for {layer_type}.")
@register_quantization_config(ASCEND_QUANTIZATION_METHOD)
@@ -84,40 +86,6 @@ class AscendModelSlimConfig310(AscendModelSlimConfig):
causing NZ/transpose issues on 310P.
"""
def _get_linear_quant_type(self, prefix: str) -> str | None:
"""Packed-aware quant type lookup.
ModelSlim may describe fused modules by their shards.
Example:
prefix = "...qkv_proj" -> shards "...q_proj.weight", "...k_proj.weight", "...v_proj.weight"
"""
fused_mapping = getattr(self, "packed_modules_mapping", {}) or {}
proj_name = prefix.split(".")[-1]
if proj_name in fused_mapping:
shard_prefixes = [
prefix.replace(proj_name, shard_proj_name) for shard_proj_name in fused_mapping[proj_name]
]
quant_types: list[str] = []
for sp in shard_prefixes:
qt = self.quant_description.get(sp + ".weight")
if isinstance(qt, str):
quant_types.append(qt)
if not quant_types:
return None
first = quant_types[0]
if any(q != first for q in quant_types[1:]):
raise ValueError(
f"310P quantization: not all shards of fused layer '{prefix}' "
f"share the same quant type. shards={shard_prefixes}, types={quant_types}"
)
return first
qt = self.quant_description.get(prefix + ".weight")
return qt if isinstance(qt, str) else None
def get_quant_method(
self,
layer: torch.nn.Module,
@@ -141,7 +109,6 @@ class AscendModelSlimConfig310(AscendModelSlimConfig):
return AscendUnquantizedLinearMethod()
scheme = create_scheme_for_layer(
cfg=self,
quant_description=self.quant_description,
prefix=prefix,
layer_type="linear",
@@ -149,14 +116,15 @@ class AscendModelSlimConfig310(AscendModelSlimConfig):
)
return AscendLinearMethod(scheme)
if isinstance(layer, VocabParallelEmbedding):
elif isinstance(layer, FusedMoE):
if self.is_layer_skipped_ascend(prefix, self.packed_modules_mapping):
from vllm_ascend._310p.fused_moe.fused_moe import AscendUnquantizedFusedMoEMethod310
return AscendUnquantizedFusedMoEMethod310(layer.moe_config)
scheme = create_scheme_for_layer(self.quant_description, prefix, "moe", self.packed_modules_mapping)
return AscendFusedMoEMethod(scheme, layer.moe_config)
elif isinstance(layer, VocabParallelEmbedding):
return UnquantizedEmbeddingMethod()
if isinstance(layer, FusedMoE):
raise NotImplementedError(
"310P quantization: FusedMoE is not supported yet. "
"TODO: add 310P MoE quant schemes and routing. "
"Workaround: use a non-MoE model."
)
return super().get_quant_method(layer, prefix)