[Mini-vLLM] SM86-only cut: models, backends, Rust, tests
- Keep only Qwen3.5, Qwen3.5-MTP and Qwen4Exp model paths; trim the model registry to 41 entries - Delete idle attention backends (MLA, FlashInfer, ROCm-only, quant backends) and dead GDN CuTeDSL kernels - Remove inc/quark quant loaders; keep compressed-tensors and Marlin - Drop the Rust frontend, pooling entrypoints, and idle test suites - Rebuild kernels for sm_80;sm_86 and strip the extensions - Verified: full import sweep clean (optional deps only) and a dummy-load Qwen3.5 engine run on RTX 3090 via the Triton GDN path Co-authored-by: Hinata <hinata@idihore.id> Signed-off-by: MOVZX <movzx@yahoo.com>
This commit is contained in:
@@ -20,40 +20,8 @@ def get_quark_ocp_mx_group_size(
|
||||
quant_config: "QuantizationConfig | None",
|
||||
layer_name: str,
|
||||
) -> int | None:
|
||||
"""Return the OCP MX group size for a quantized Quark linear layer."""
|
||||
if quant_config is None:
|
||||
return None
|
||||
|
||||
from vllm.model_executor.layers.quantization.quark.quark import QuarkConfig
|
||||
from vllm.model_executor.layers.quantization.quark.utils import should_ignore_layer
|
||||
|
||||
if not isinstance(quant_config, QuarkConfig):
|
||||
return None
|
||||
|
||||
if should_ignore_layer(
|
||||
layer_name,
|
||||
ignore=quant_config.quant_config.get("exclude") or [],
|
||||
fused_mapping=quant_config.packed_modules_mapping,
|
||||
):
|
||||
return None
|
||||
|
||||
layer_quant_config = (
|
||||
quant_config.get_layer_quant_config_from_name(layer_name)
|
||||
or quant_config.quant_config.get("global_quant_config")
|
||||
or {}
|
||||
)
|
||||
weight_quant = layer_quant_config.get("weight")
|
||||
input_quant = layer_quant_config.get("input_tensors")
|
||||
if not quant_config._is_w_ocp_mx_a_x(weight_quant, input_quant):
|
||||
return None
|
||||
|
||||
assert weight_quant is not None
|
||||
group_size = weight_quant.get("group_size")
|
||||
if group_size is None:
|
||||
block_size = weight_quant.get("block_size")
|
||||
if isinstance(block_size, list | tuple) and len(block_size) >= 2:
|
||||
group_size = block_size[1]
|
||||
return int(group_size) if group_size is not None else None
|
||||
"""Quark support was removed; kept for callers that probe MX group size."""
|
||||
return None
|
||||
|
||||
|
||||
def is_shared_expert_quant_fse_compatible(
|
||||
@@ -75,12 +43,9 @@ def is_shared_expert_quant_fse_compatible(
|
||||
|
||||
"""
|
||||
from vllm.model_executor.layers.quantization.fp8 import Fp8Config
|
||||
from vllm.model_executor.layers.quantization.online.fp8 import OnlineLinearBase
|
||||
from vllm.model_executor.layers.quantization.quark.quark import QuarkConfig
|
||||
from vllm.model_executor.layers.quantization.utils.quant_utils import (
|
||||
is_layer_skipped,
|
||||
)
|
||||
from vllm.models.deepseek_v4.quant_config import DeepseekV4FP8Config
|
||||
|
||||
if projection_names is None:
|
||||
projection_names = ["gate_up_proj", "down_proj"]
|
||||
@@ -104,191 +69,12 @@ def is_shared_expert_quant_fse_compatible(
|
||||
shared_expert_targets = None
|
||||
|
||||
if shared_expert_targets is not None:
|
||||
from vllm.model_executor.layers.fused_moe import RoutedExperts
|
||||
from vllm.model_executor.layers.linear import UnquantizedLinearMethod
|
||||
from vllm.model_executor.layers.quantization.online.base import (
|
||||
ONLINE_SHARED_EXPERT_QUANTIZERS,
|
||||
)
|
||||
|
||||
# NOTE: online shared experts quantization check is only implemented for quark
|
||||
# quant method at the moment. This can be extended here for other quant methods.
|
||||
# Requirement is:
|
||||
# - Retrieve routed weight quant key
|
||||
# - Retrieve routed activation quant key
|
||||
# and ensure the online quantization set on shared expert match them.
|
||||
if isinstance(quant_config, QuarkConfig):
|
||||
routed_weight_key, routed_activation_key, _ = (
|
||||
quant_config.get_quant_method_target(expert_prefix, RoutedExperts)
|
||||
)
|
||||
else:
|
||||
reason = (
|
||||
"online quantization FSE compatibility check is not implemented for "
|
||||
f"{type(quant_config).__name__}"
|
||||
)
|
||||
logger.warning_once(reason)
|
||||
return False, reason
|
||||
|
||||
if routed_weight_key not in ONLINE_SHARED_EXPERT_QUANTIZERS:
|
||||
return (
|
||||
False,
|
||||
"online shared-expert quantization is not supported for routed "
|
||||
f"expert weight key {routed_weight_key}",
|
||||
)
|
||||
|
||||
for shared_expert_target in shared_expert_targets:
|
||||
if shared_expert_target is None:
|
||||
return (
|
||||
False,
|
||||
"online quantization targets only part of the shared expert at "
|
||||
f"{shared_expert_prefix}",
|
||||
)
|
||||
|
||||
_, _, _, shared_quant_spec, shared_method_cls = shared_expert_target
|
||||
if shared_method_cls in (None, UnquantizedLinearMethod):
|
||||
return (
|
||||
False,
|
||||
"online quantization excludes FSE weights at "
|
||||
f"{shared_expert_prefix}",
|
||||
)
|
||||
assert issubclass(shared_method_cls, OnlineLinearBase)
|
||||
|
||||
# NOTE: We can not rely on shared_quant_spec.activation_quant_key
|
||||
# as _ONLINE_SHORTHANDS: dict[str, QuantSpec] in quantization.py
|
||||
# does not define the default activation quant key.
|
||||
# `online_quant_config.resolve_quant_method_cls` should return the
|
||||
# activation quant key as well. Only some online methods define it
|
||||
# on the class, so compare the weight key first.
|
||||
if (
|
||||
shared_quant_spec.weight != routed_weight_key
|
||||
or shared_method_cls.activation_quant_key != routed_activation_key
|
||||
):
|
||||
return (
|
||||
False,
|
||||
"online shared-expert quantization keys do not match the "
|
||||
"routed expert keys",
|
||||
)
|
||||
return True, None
|
||||
|
||||
if isinstance(quant_config, DeepseekV4FP8Config):
|
||||
from vllm.config import get_current_vllm_config
|
||||
from vllm.model_executor.models.utils import extract_layer_index
|
||||
|
||||
if quant_config.expert_dtype != "fp4":
|
||||
return False, "DeepSeek-V4 routed experts are not MXFP4"
|
||||
|
||||
hf_config = get_current_vllm_config().model_config.hf_config
|
||||
|
||||
# TODO: This is adapted from former `_shared_experts_are_fp4`, and
|
||||
# needs to be cleaned up this . There should not be Quark-specific
|
||||
# logic in DeepseekV4FP8Config.
|
||||
quantization_config = getattr(hf_config, "quantization_config", None)
|
||||
if quantization_config is None:
|
||||
return False, "DeepSeek-V4 has no quantization configuration"
|
||||
|
||||
if not quant_config._is_quark_mxfp4_ocp(quantization_config):
|
||||
return False, "DeepSeek-v4 FSE is only implemented/tested with Quark MXFP4"
|
||||
|
||||
layer_idx = extract_layer_index(shared_expert_prefix)
|
||||
if layer_idx >= hf_config.num_hidden_layers:
|
||||
shared_expert_prefix = (
|
||||
f"mtp.{layer_idx - hf_config.num_hidden_layers}.ffn.shared_experts"
|
||||
)
|
||||
else:
|
||||
shared_expert_prefix = f"layers.{layer_idx}.ffn.shared_experts"
|
||||
|
||||
if any(
|
||||
entry.startswith(shared_expert_prefix)
|
||||
for entry in quantization_config.get("exclude") or []
|
||||
if isinstance(entry, str)
|
||||
):
|
||||
return (
|
||||
False,
|
||||
f"DeepSeek-V4 excludes shared experts at {shared_expert_prefix}",
|
||||
)
|
||||
|
||||
shared_expert_weight_name = f"{shared_expert_prefix}.w1"
|
||||
layer_quant_config = quantization_config.get("layer_quant_config") or {}
|
||||
layer_config = layer_quant_config.get(shared_expert_weight_name)
|
||||
if layer_config is None:
|
||||
layer_config = next(
|
||||
(
|
||||
config
|
||||
for pattern, config in layer_quant_config.items()
|
||||
if isinstance(pattern, str)
|
||||
and pattern.startswith("re:")
|
||||
and re.fullmatch(
|
||||
pattern.removeprefix("re:"), shared_expert_weight_name
|
||||
)
|
||||
),
|
||||
None,
|
||||
)
|
||||
shared_weight_config = (
|
||||
layer_config or quantization_config.get("global_quant_config") or {}
|
||||
).get("weight") or {}
|
||||
if shared_weight_config.get("dtype") == "fp4":
|
||||
return True, None
|
||||
return (
|
||||
False,
|
||||
f"DeepSeek-V4 shared experts at {shared_expert_prefix} are not MXFP4",
|
||||
)
|
||||
|
||||
if isinstance(quant_config, QuarkConfig):
|
||||
from vllm.model_executor.layers.quantization.quark.utils import (
|
||||
should_ignore_layer,
|
||||
)
|
||||
|
||||
# TODO: layer_type_quant_config is not taken into account here.
|
||||
assert "exclude" in quant_config.quant_config
|
||||
assert "global_quant_config" in quant_config.quant_config
|
||||
|
||||
exclude = quant_config.quant_config["exclude"]
|
||||
|
||||
# should_ignore_layer raises a rightful ValueError in case different shards
|
||||
# have a different ignore policy, as unsupported.
|
||||
is_excluded = any(
|
||||
should_ignore_layer(
|
||||
f"{shared_expert_prefix}.{projection_name}",
|
||||
ignore=exclude,
|
||||
fused_mapping=quant_config.packed_modules_mapping,
|
||||
)
|
||||
for projection_name in projection_names
|
||||
)
|
||||
if is_excluded:
|
||||
return False, f"Quark excludes shared experts at {shared_expert_prefix}"
|
||||
|
||||
global_quant_config = quant_config.quant_config["global_quant_config"]
|
||||
|
||||
def get_projection_quant_configs(layer_name: str) -> list[object]:
|
||||
module_prefix, _, projection_name = layer_name.rpartition(".")
|
||||
packed_projection_names = quant_config.packed_modules_mapping.get(
|
||||
projection_name, [projection_name]
|
||||
)
|
||||
return [
|
||||
quant_config.get_layer_quant_config_from_name(
|
||||
f"{module_prefix}.{packed_projection_name}"
|
||||
)
|
||||
or global_quant_config
|
||||
for packed_projection_name in packed_projection_names
|
||||
]
|
||||
|
||||
expert_quant_config = (
|
||||
quant_config.get_layer_quant_config_from_name(expert_prefix)
|
||||
or global_quant_config
|
||||
)
|
||||
shared_expert_quant_configs = [
|
||||
config
|
||||
for projection_name in projection_names
|
||||
for config in get_projection_quant_configs(
|
||||
f"{shared_expert_prefix}.{projection_name}"
|
||||
)
|
||||
]
|
||||
if all(config == expert_quant_config for config in shared_expert_quant_configs):
|
||||
return True, None
|
||||
return (
|
||||
False,
|
||||
"Quark uses different quantization configurations for routed and "
|
||||
f"shared experts at {shared_expert_prefix}",
|
||||
reason = (
|
||||
"online quantization FSE compatibility check is not implemented for "
|
||||
f"{type(quant_config).__name__}"
|
||||
)
|
||||
logger.warning_once(reason)
|
||||
return False, reason
|
||||
|
||||
if isinstance(quant_config, Fp8Config):
|
||||
if quant_config.store_dtype is not None:
|
||||
|
||||
@@ -52,16 +52,6 @@ def is_fp8(x: torch.dtype | torch.Tensor) -> bool:
|
||||
|
||||
def get_fp8_block_weight_scale(layer: torch.nn.Module) -> torch.Tensor | None:
|
||||
"""Return the block-FP8 weight scale for supported quant methods."""
|
||||
# Local import avoids a circular import: quark_w8a8_fp8 imports this module.
|
||||
from vllm.model_executor.layers.quantization.quark.schemes.quark_w8a8_fp8 import (
|
||||
QuarkW8A8Fp8PerBlock,
|
||||
)
|
||||
|
||||
if isinstance(
|
||||
getattr(layer, "scheme", None),
|
||||
QuarkW8A8Fp8PerBlock,
|
||||
):
|
||||
return getattr(layer, "weight_scale", None)
|
||||
return getattr(layer, "weight_scale_inv", None)
|
||||
|
||||
|
||||
|
||||
@@ -549,15 +549,6 @@ def mxfp4_quantize(x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
|
||||
if current_platform.is_xpu():
|
||||
return xpu_mxfp4_quantize(x)
|
||||
|
||||
from vllm._aiter_ops import is_aiter_found_and_supported
|
||||
|
||||
if is_aiter_found_and_supported() and x.dtype == torch.bfloat16:
|
||||
from vllm.model_executor.layers.quantization.quark.utils import (
|
||||
quark_quantize_weight_to_mxfp4,
|
||||
)
|
||||
|
||||
return quark_quantize_weight_to_mxfp4(x)
|
||||
|
||||
quant_tensor, scale, _ = downcast_to_mxfp(x, axis=-1)
|
||||
|
||||
return quant_tensor, scale
|
||||
|
||||
Reference in New Issue
Block a user