# SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project import typing from collections.abc import Callable, Iterable from itertools import islice import regex as re import torch import torch.nn as nn from vllm.config import VllmConfig from vllm.distributed import ( get_ep_group, get_pp_group, get_tensor_model_parallel_rank, get_tensor_model_parallel_world_size, ) from vllm.forward_context import get_forward_context from vllm.model_executor.layers.activation import SiluAndMul, SiluAndMulWithClamp from vllm.model_executor.layers.fused_moe import ( FusedMoEFactory, GateLinear, fused_moe_make_expert_params_mapping, ) from vllm.model_executor.layers.fused_moe.router.fused_topk_bias_router import ( fused_topk_bias, ) from vllm.model_executor.layers.layernorm import RMSNorm from vllm.model_executor.layers.linear import ( MergedColumnParallelLinear, RowParallelLinear, ) from vllm.model_executor.layers.logits_processor import LogitsProcessor from vllm.model_executor.layers.mhc import ( HCHeadOp, MHCFusedPostPreOp, MHCPostOp, MHCPreOp, ) from vllm.model_executor.layers.quantization import QuantizationConfig from vllm.model_executor.layers.vocab_parallel_embedding import ( ParallelLMHead, VocabParallelEmbedding, ) from vllm.model_executor.model_loader.weight_utils import default_weight_loader from vllm.model_executor.models.interfaces import ( EagleModelMixin, SupportsEagle3, SupportsLoRA, SupportsPP, ) from vllm.model_executor.models.utils import ( AutoWeightsLoader, PPMissingLayer, WeightsMapper, extract_layer_index, is_pp_missing_parameter, make_layers, maybe_prefix, ) from vllm.model_executor.utils import set_weight_attrs from vllm.models.deepseek_v4.xpu.xpu_sparse import DeepseekV4XPUAttention from vllm.platforms import current_platform from vllm.sequence import IntermediateTensors from vllm.triton_utils import tl, triton from vllm.utils.torch_utils import direct_register_custom_op class DeepseekV4MLP(nn.Module): def __init__( self, hidden_size: int, intermediate_size: int, hidden_act: str, swiglu_limit: float | None = None, quant_config: QuantizationConfig | None = None, reduce_results: bool = True, is_sequence_parallel: bool = False, prefix: str = "", ) -> None: super().__init__() # If is_sequence_parallel, the input and output tensors are sharded # across the ranks within the tp_group. In this case the weights are # replicated and no collective ops are needed. # Otherwise we use standard TP with an allreduce at the end. self.gate_up_proj = MergedColumnParallelLinear( hidden_size, [intermediate_size] * 2, bias=False, quant_config=quant_config, disable_tp=is_sequence_parallel, prefix=f"{prefix}.gate_up_proj", ) self.down_proj = RowParallelLinear( intermediate_size, hidden_size, bias=False, quant_config=quant_config, reduce_results=reduce_results, disable_tp=is_sequence_parallel, prefix=f"{prefix}.down_proj", ) if hidden_act != "silu": raise ValueError( f"Unsupported activation: {hidden_act}. Only silu is supported for now." ) if swiglu_limit is not None: self.act_fn = SiluAndMulWithClamp(swiglu_limit) else: self.act_fn = SiluAndMul() def forward(self, x): gate_up, _ = self.gate_up_proj(x) x = self.act_fn(gate_up) x, _ = self.down_proj(x) return x @triton.jit def _deepseek_v4_stage_mega_moe_inputs_kernel( hidden_states, x_fp8, x_sf, topk_ids, topk_weights, topk_idx_out, topk_weights_out, hidden_stride_m: tl.constexpr, hidden_stride_k: tl.constexpr, x_stride_m: tl.constexpr, x_stride_k: tl.constexpr, x_sf_stride_m: tl.constexpr, x_sf_stride_k: tl.constexpr, topk_ids_stride_m: tl.constexpr, topk_ids_stride_k: tl.constexpr, topk_weights_stride_m: tl.constexpr, topk_weights_stride_k: tl.constexpr, topk_idx_stride_m: tl.constexpr, topk_idx_stride_k: tl.constexpr, topk_weights_out_stride_m: tl.constexpr, topk_weights_out_stride_k: tl.constexpr, hidden_size: tl.constexpr, top_k: tl.constexpr, BLOCK_K: tl.constexpr, GROUP_K: tl.constexpr, BLOCK_TOPK: tl.constexpr, ) -> None: token_id = tl.program_id(0) k_block_id = tl.program_id(1) k_offsets = k_block_id * BLOCK_K + tl.arange(0, BLOCK_K) k_mask = k_offsets < hidden_size hidden = tl.load( hidden_states + token_id * hidden_stride_m + k_offsets * hidden_stride_k, mask=k_mask, other=0.0, ).to(tl.float32) num_groups: tl.constexpr = BLOCK_K // GROUP_K hidden_groups = tl.reshape(tl.abs(hidden), [num_groups, GROUP_K]) amax = tl.max(hidden_groups, axis=1) amax = tl.maximum(amax, 1.0e-4) scale = amax / 448.0 scale_bits = scale.to(tl.uint32, bitcast=True) scale_exp = ((scale_bits >> 23) & 0xFF) + ((scale_bits & 0x7FFFFF) != 0).to( tl.uint32 ) scale_exp = tl.minimum(tl.maximum(scale_exp, 1), 254) rounded_scale = (scale_exp << 23).to(tl.float32, bitcast=True) hidden_groups = tl.reshape(hidden, [num_groups, GROUP_K]) scaled = hidden_groups * (1.0 / rounded_scale)[:, None] scaled = tl.reshape(scaled, [BLOCK_K]) fp8 = scaled.to(tl.float8e4nv) tl.store( x_fp8 + token_id * x_stride_m + k_offsets * x_stride_k, fp8, mask=k_mask, ) scale_offsets = tl.arange(0, num_groups) packed_scale = tl.sum(scale_exp << (scale_offsets * 8), axis=0).to(tl.int32) tl.store( x_sf + token_id * x_sf_stride_m + k_block_id * x_sf_stride_k, packed_scale, ) if k_block_id == 0: topk_offsets = tl.arange(0, BLOCK_TOPK) topk_mask = topk_offsets < top_k ids = tl.load( topk_ids + token_id * topk_ids_stride_m + topk_offsets * topk_ids_stride_k, mask=topk_mask, other=0, ).to(tl.int64) tl.store( topk_idx_out + token_id * topk_idx_stride_m + topk_offsets * topk_idx_stride_k, ids, mask=topk_mask, ) weights = tl.load( topk_weights + token_id * topk_weights_stride_m + topk_offsets * topk_weights_stride_k, mask=topk_mask, other=0.0, ) tl.store( topk_weights_out + token_id * topk_weights_out_stride_m + topk_offsets * topk_weights_out_stride_k, weights, mask=topk_mask, ) def _stage_deepseek_v4_mega_moe_inputs( hidden_states: torch.Tensor, topk_weights: torch.Tensor, topk_ids: torch.Tensor, x_fp8: torch.Tensor, x_sf: torch.Tensor, topk_idx_out: torch.Tensor, topk_weights_out: torch.Tensor, ) -> None: num_tokens, hidden_size = hidden_states.shape if num_tokens == 0: return if hidden_size % 128 != 0: raise ValueError( "DeepSeek V4 MegaMoE input staging requires hidden_size to be " "a multiple of 128." ) top_k = topk_ids.shape[1] if topk_weights.shape != topk_ids.shape: raise ValueError( "DeepSeek V4 MegaMoE input staging requires topk_weights and " "topk_ids to have the same shape." ) block_k = 128 grid = (num_tokens, triton.cdiv(hidden_size, block_k)) block_topk = triton.next_power_of_2(top_k) _deepseek_v4_stage_mega_moe_inputs_kernel[grid]( hidden_states, x_fp8, x_sf, topk_ids, topk_weights, topk_idx_out, topk_weights_out, hidden_states.stride(0), hidden_states.stride(1), x_fp8.stride(0), x_fp8.stride(1), x_sf.stride(0), x_sf.stride(1), topk_ids.stride(0), topk_ids.stride(1), topk_weights.stride(0), topk_weights.stride(1), topk_idx_out.stride(0), topk_idx_out.stride(1), topk_weights_out.stride(0), topk_weights_out.stride(1), hidden_size, top_k, BLOCK_K=block_k, GROUP_K=32, BLOCK_TOPK=block_topk, num_warps=4, ) def make_deepseek_v4_expert_params_mapping( num_experts: int, ) -> list[tuple[str, str, int, str]]: return [ ( "experts.w13_" if shard_id in ("w1", "w3") else "experts.w2_", f"experts.{expert_id}.{weight_name}.", expert_id, shard_id, ) for expert_id in range(num_experts) for shard_id, weight_name in [ ("w1", "w1"), ("w2", "w2"), ("w3", "w3"), ] ] class DeepseekV4MegaMoEExperts(nn.Module): _symm_buffer_cache: dict[tuple[int, int, int, int, int, int, int], object] = {} def __init__( self, vllm_config: VllmConfig, *, num_experts: int, num_local_experts: int, experts_start_idx: int, top_k: int, hidden_size: int, intermediate_size: int, prefix: str = "", ): super().__init__() self.prefix = prefix self.num_experts = num_experts self.num_local_experts = num_local_experts self.experts_start_idx = experts_start_idx self.experts_end_idx = experts_start_idx + num_local_experts self.top_k = top_k self.hidden_size = hidden_size self.intermediate_size = intermediate_size self.max_num_tokens = vllm_config.scheduler_config.max_num_batched_tokens weight_attrs = {"weight_loader": self.weight_loader} self.w13_weight = nn.Parameter( torch.zeros( num_local_experts, 2 * intermediate_size, hidden_size // 2, dtype=torch.uint8, ), requires_grad=False, ) set_weight_attrs(self.w13_weight, weight_attrs) self.w13_weight_scale = nn.Parameter( torch.zeros( num_local_experts, 2 * intermediate_size, hidden_size // 32, dtype=torch.uint8, ), requires_grad=False, ) set_weight_attrs(self.w13_weight_scale, weight_attrs) self.w13_weight_scale.quant_method = "block" self.w2_weight = nn.Parameter( torch.zeros( num_local_experts, hidden_size, intermediate_size // 2, dtype=torch.uint8, ), requires_grad=False, ) set_weight_attrs(self.w2_weight, weight_attrs) self.w2_weight_scale = nn.Parameter( torch.zeros( num_local_experts, hidden_size, intermediate_size // 32, dtype=torch.uint8, ), requires_grad=False, ) set_weight_attrs(self.w2_weight_scale, weight_attrs) self.w2_weight_scale.quant_method = "block" self._transformed_l1_weights: tuple[torch.Tensor, torch.Tensor] | None = None self._transformed_l2_weights: tuple[torch.Tensor, torch.Tensor] | None = None # Register in the static forward context so the custom-op wrapper # can look up this module by name from within a torch.compile graph. compilation_config = vllm_config.compilation_config if prefix in compilation_config.static_forward_context: raise ValueError(f"Duplicate layer name: {prefix}") compilation_config.static_forward_context[prefix] = self def _map_global_expert_id(self, expert_id: int) -> int: if expert_id < self.experts_start_idx or expert_id >= self.experts_end_idx: return -1 return expert_id - self.experts_start_idx def weight_loader( self, param: nn.Parameter, loaded_weight: torch.Tensor, weight_name: str, shard_id: str, expert_id: int, return_success: bool = False, ) -> bool | None: local_expert_id = self._map_global_expert_id(expert_id) if local_expert_id == -1: return False if return_success else None expert_data = param.data[local_expert_id] if shard_id in ("w1", "w3"): if "w13_" not in weight_name: return False if return_success else None shard_offset = 0 if shard_id == "w1" else self.intermediate_size expert_data = expert_data.narrow(0, shard_offset, self.intermediate_size) elif shard_id == "w2": if "w2_" not in weight_name: return False if return_success else None else: raise ValueError(f"Unsupported expert shard id: {shard_id}") if expert_data.shape != loaded_weight.shape: raise ValueError( f"DeepSeek V4 MegaMoE expert weight shape mismatch for " f"{weight_name}: parameter shard {tuple(expert_data.shape)} " f"vs checkpoint {tuple(loaded_weight.shape)}" ) expert_data.copy_(loaded_weight) return True if return_success else None @staticmethod def _ue8m0_uint8_to_float(sf: torch.Tensor) -> torch.Tensor: return (sf.to(torch.int32) << 23).view(torch.float32) def _check_runtime_supported(self) -> None: raise NotImplementedError("DeepSeek V4 MegaMoE is not supported on XPU.") def finalize_weights(self) -> None: if self._transformed_l1_weights is not None: return self._check_runtime_supported() import vllm.third_party.deep_gemm as deep_gemm w13_scale = deep_gemm.transform_sf_into_required_layout( self._ue8m0_uint8_to_float(self.w13_weight_scale.data).contiguous(), 2 * self.intermediate_size, self.hidden_size, (1, 32), self.num_local_experts, ) w2_scale = deep_gemm.transform_sf_into_required_layout( self._ue8m0_uint8_to_float(self.w2_weight_scale.data).contiguous(), self.hidden_size, self.intermediate_size, (1, 32), self.num_local_experts, ) self._transformed_l1_weights, self._transformed_l2_weights = ( deep_gemm.transform_weights_for_mega_moe( (self.w13_weight.data.view(torch.int8).contiguous(), w13_scale), (self.w2_weight.data.view(torch.int8).contiguous(), w2_scale), ) ) # Drop the original loader-side parameters: the MegaMoE kernels only # consume the transformed views above. transform_weights_for_mega_moe # allocates a fresh tensor for the L1 weight (see _interleave_l1_weights) # and fresh SF tensors for L1/L2; the L2 weight is the only tensor that # aliases the original storage, and _transformed_l2_weights still holds # it, so the storage stays live after we drop the Parameter. self.w13_weight = None self.w13_weight_scale = None self.w2_weight = None self.w2_weight_scale = None def get_symm_buffer(self): import vllm.third_party.deep_gemm as deep_gemm group = get_ep_group().device_group device = torch.accelerator.current_device_index() key = ( id(group), device, self.num_experts, self.max_num_tokens, self.top_k, self.hidden_size, self.intermediate_size, ) symm_buffer = self._symm_buffer_cache.get(key) if symm_buffer is None: symm_buffer = deep_gemm.get_symm_buffer_for_mega_moe( group, self.num_experts, self.max_num_tokens, self.top_k, self.hidden_size, self.intermediate_size, ) self._symm_buffer_cache[key] = symm_buffer return symm_buffer def forward( self, hidden_states: torch.Tensor, topk_weights: torch.Tensor, topk_ids: torch.Tensor, *, activation_clamp: float | None, fast_math: bool = True, ) -> torch.Tensor: if hidden_states.shape[0] > self.max_num_tokens: raise ValueError( f"DeepSeek V4 MegaMoE got {hidden_states.shape[0]} tokens, " f"but the symmetric buffer was sized for {self.max_num_tokens}." ) y = torch.empty_like(hidden_states, dtype=torch.bfloat16) torch.ops.vllm.deepseek_v4_mega_moe_experts( hidden_states, topk_weights, topk_ids, y, self.prefix, activation_clamp, fast_math, ) return y def _run_mega_moe( self, hidden_states: torch.Tensor, topk_weights: torch.Tensor, topk_ids: torch.Tensor, y: torch.Tensor, activation_clamp: float | None, fast_math: bool, ) -> None: import vllm.third_party.deep_gemm as deep_gemm symm_buffer = self.get_symm_buffer() num_tokens = hidden_states.shape[0] _stage_deepseek_v4_mega_moe_inputs( hidden_states, topk_weights, topk_ids, symm_buffer.x[:num_tokens], symm_buffer.x_sf[:num_tokens], symm_buffer.topk_idx[:num_tokens], symm_buffer.topk_weights[:num_tokens], ) # This method must have been already called during the weight loading phase. # We call it again here to cover the dummy weight loading case. self.finalize_weights() assert self._transformed_l1_weights is not None assert self._transformed_l2_weights is not None deep_gemm.fp8_fp4_mega_moe( y, self._transformed_l1_weights, self._transformed_l2_weights, symm_buffer, activation_clamp=activation_clamp, fast_math=fast_math, ) DeepseekV4MegaMoEExperts.weight_loader.supports_moe_loading = True # type: ignore[attr-defined] def _deepseek_v4_mega_moe_experts_op( hidden_states: torch.Tensor, topk_weights: torch.Tensor, topk_ids: torch.Tensor, out: torch.Tensor, layer_name: str, activation_clamp: float | None, fast_math: bool, ) -> None: self = get_forward_context().no_compile_layers[layer_name] self._run_mega_moe( hidden_states, topk_weights, topk_ids, out, activation_clamp, fast_math, ) direct_register_custom_op( op_name="deepseek_v4_mega_moe_experts", op_func=_deepseek_v4_mega_moe_experts_op, mutates_args=["out"], ) class DeepseekV4MoE(nn.Module): def __init__( self, vllm_config: VllmConfig, prefix: str = "", ): super().__init__() self.tp_size = get_tensor_model_parallel_world_size() config = vllm_config.model_config.hf_config quant_config = vllm_config.quant_config self.prefix = prefix self.use_mega_moe = ( vllm_config.kernel_config.moe_backend == "deep_gemm_mega_moe" ) if self.use_mega_moe and not vllm_config.parallel_config.enable_expert_parallel: raise NotImplementedError( "DeepSeek V4 MegaMoE currently requires expert parallel. " "Enable it with --enable-expert-parallel, or pick a different " "moe backend." ) self.routed_scaling_factor = getattr(config, "routed_scaling_factor", 1.0) self.hidden_size = config.hidden_size self.n_routed_experts = config.n_routed_experts self.n_activated_experts = config.num_experts_per_tok self.moe_intermediate_size = config.moe_intermediate_size self.swiglu_limit = config.swiglu_limit self.renormalize = config.norm_topk_prob self.scoring_func = getattr(config, "scoring_func", "sqrtsoftplus") if self.use_mega_moe and self.scoring_func != "sqrtsoftplus": raise NotImplementedError( "DeepSeek V4 MegaMoE currently supports sqrtsoftplus routing only." ) if self.use_mega_moe and getattr(config, "expert_dtype", "fp4") != "fp4": raise NotImplementedError( "DeepSeek V4 MegaMoE only supports fp4 experts; got expert_dtype=" f"{config.expert_dtype!r}. Drop --kernel-config moe_backend=" "deep_gemm_mega_moe for this checkpoint." ) self.gate = GateLinear( input_size=config.hidden_size, output_size=config.n_routed_experts, bias=False, out_dtype=torch.float32, prefix=f"{prefix}.gate", ) self.gate.e_score_correction_bias = None self.gate.tid2eid = None is_hash_moe = extract_layer_index(prefix) < config.mlp_layer_types.count( "hash_moe" ) self.hash_indices_dtype = torch.int64 if self.use_mega_moe else torch.int32 if is_hash_moe: # hash MoE doesn't use e_score_correction_bias # Use randint instead of empty to avoid garbage values causing # invalid memory access in dummy mode (--load-format="dummy") self.gate.tid2eid = nn.Parameter( torch.randint( 0, config.n_routed_experts, (config.vocab_size, config.num_experts_per_tok), dtype=self.hash_indices_dtype, ), requires_grad=False, ) elif getattr(config, "topk_method", None) == "noaux_tc": self.gate.e_score_correction_bias = nn.Parameter( torch.empty(config.n_routed_experts, dtype=torch.float32), requires_grad=False, ) if config.n_shared_experts is None: self.shared_experts = None else: intermediate_size = config.moe_intermediate_size * config.n_shared_experts self.shared_experts = DeepseekV4MLP( hidden_size=config.hidden_size, intermediate_size=intermediate_size, hidden_act=config.hidden_act, swiglu_limit=self.swiglu_limit, quant_config=quant_config, reduce_results=self.use_mega_moe, prefix=f"{prefix}.shared_experts", ) if self.use_mega_moe: self._init_mega_moe_experts(vllm_config, config, prefix) else: self._init_fused_moe_experts(config, quant_config, prefix) def _init_mega_moe_experts( self, vllm_config: VllmConfig, config, prefix: str, ) -> None: self.ep_group = get_ep_group() self.ep_size = self.ep_group.world_size self.ep_rank = self.ep_group.rank_in_group assert config.n_routed_experts % self.ep_size == 0 self.n_local_experts = config.n_routed_experts // self.ep_size self.experts_start_idx = self.ep_rank * self.n_local_experts self.experts_end_idx = self.experts_start_idx + self.n_local_experts self.experts = DeepseekV4MegaMoEExperts( vllm_config, num_experts=config.n_routed_experts, num_local_experts=self.n_local_experts, experts_start_idx=self.experts_start_idx, top_k=config.num_experts_per_tok, hidden_size=config.hidden_size, intermediate_size=config.moe_intermediate_size, prefix=f"{prefix}.experts", ) def _init_fused_moe_experts( self, config, quant_config, prefix: str, ) -> None: self.tp_rank = get_tensor_model_parallel_rank() assert config.n_routed_experts % self.tp_size == 0 self.n_local_experts = config.n_routed_experts // self.tp_size self.experts_start_idx = self.tp_rank * self.n_local_experts self.experts_end_idx = self.experts_start_idx + self.n_local_experts self.experts = FusedMoEFactory( shared_experts=self.shared_experts, gate=self.gate, num_experts=config.n_routed_experts, top_k=config.num_experts_per_tok, hidden_size=config.hidden_size, intermediate_size=config.moe_intermediate_size, renormalize=config.norm_topk_prob, quant_config=quant_config, prefix=f"{prefix}.experts", scoring_func=self.scoring_func, routed_scaling_factor=self.routed_scaling_factor, e_score_correction_bias=self.gate.e_score_correction_bias, hash_indices_table=self.gate.tid2eid, swiglu_limit=self.swiglu_limit, router_logits_dtype=torch.float32, ) def forward( self, hidden_states: torch.Tensor, input_ids: torch.Tensor | None = None ) -> torch.Tensor: if self.gate.tid2eid is not None and input_ids is None: raise ValueError("DeepSeek V4 hash MoE routing requires input_ids.") if not self.use_mega_moe: return self._forward_fused_moe(hidden_states, input_ids) org_shape = hidden_states.shape router_logits, _ = self.gate(hidden_states) topk_weights, topk_ids = fused_topk_bias( hidden_states=hidden_states, gating_output=router_logits, scoring_func=self.scoring_func, e_score_correction_bias=self.gate.e_score_correction_bias.data if self.gate.e_score_correction_bias is not None else None, topk=self.n_activated_experts, renormalize=self.renormalize, indices_type=self.hash_indices_dtype, input_tokens=input_ids, hash_indices_table=self.gate.tid2eid, routed_scaling_factor=self.routed_scaling_factor, ) activation_clamp = ( float(self.swiglu_limit) if self.swiglu_limit is not None else None ) final_hidden_states = self.experts( hidden_states, topk_weights, topk_ids, activation_clamp=activation_clamp, ) if self.shared_experts is not None: shared_output = self.shared_experts(hidden_states) final_hidden_states += shared_output return final_hidden_states.view(org_shape) def _forward_fused_moe( self, hidden_states: torch.Tensor, input_ids: torch.Tensor | None = None ) -> torch.Tensor: org_shape = hidden_states.shape final_hidden_states = self.experts( hidden_states=hidden_states, router_logits=hidden_states, input_ids=input_ids, ) return final_hidden_states.view(org_shape) def finalize_mega_moe_weights(self) -> None: if self.use_mega_moe: self.experts.finalize_weights() class DeepseekV4DecoderLayer(nn.Module): def __init__( self, vllm_config, prefix, topk_indices_buffer: torch.Tensor | None = None, aux_stream_list: list | None = None, ): super().__init__() # Lazy import to avoid top-level tilelang dependency. # Registers both torch.ops.vllm.mhc_pre and mhc_post import vllm.model_executor.layers.mhc # noqa: F401 config = vllm_config.model_config.hf_config self.hidden_size = config.hidden_size self.rms_norm_eps = config.rms_norm_eps self.attn = DeepseekV4XPUAttention( vllm_config, prefix=f"{prefix}.attn", topk_indices_buffer=topk_indices_buffer, aux_stream_list=aux_stream_list, ) self.ffn = DeepseekV4MoE(vllm_config, prefix=f"{prefix}.ffn") self.attn_norm = RMSNorm(self.hidden_size, self.rms_norm_eps) self.ffn_norm = RMSNorm(self.hidden_size, self.rms_norm_eps) self.hc_mult = config.hc_mult self.hc_sinkhorn_iters = config.hc_sinkhorn_iters self.hc_eps = config.hc_eps self.hc_post_alpha = 2.0 mix_hc = (2 + self.hc_mult) * self.hc_mult hc_dim = self.hc_mult * self.hidden_size self.hc_attn_fn = nn.Parameter( torch.empty( (mix_hc, hc_dim), dtype=torch.float32, ), requires_grad=False, ) self.hc_ffn_fn = nn.Parameter( torch.empty( (mix_hc, hc_dim), dtype=torch.float32, ), requires_grad=False, ) self.hc_attn_base = nn.Parameter( torch.empty( mix_hc, dtype=torch.float32, ), requires_grad=False, ) self.hc_ffn_base = nn.Parameter( torch.empty( mix_hc, dtype=torch.float32, ), requires_grad=False, ) self.hc_attn_scale = nn.Parameter( torch.empty( 3, dtype=torch.float32, ), requires_grad=False, ) self.hc_ffn_scale = nn.Parameter( torch.empty( 3, dtype=torch.float32, ), requires_grad=False, ) self.mhc_pre = MHCPreOp() self.mhc_post = MHCPostOp() self.mhc_fused_post_pre = MHCFusedPostPreOp() def hc_pre( self, x: torch.Tensor, hc_fn: torch.Tensor, hc_scale: torch.Tensor, hc_base: torch.Tensor, ): post_mix, res_mix, layer_input = self.mhc_pre( residual=x, fn=hc_fn, hc_scale=hc_scale, hc_base=hc_base, rms_eps=self.rms_norm_eps, hc_pre_eps=self.hc_eps, hc_sinkhorn_eps=self.hc_eps, hc_post_mult_value=self.hc_post_alpha, sinkhorn_repeat=self.hc_sinkhorn_iters, ) return layer_input, post_mix, res_mix def hc_post( self, x: torch.Tensor, residual: torch.Tensor, post: torch.Tensor, comb: torch.Tensor, ): return self.mhc_post(x, residual, post, comb) def forward( self, x: torch.Tensor, positions: torch.Tensor, input_ids: torch.Tensor | None, post_mix: torch.Tensor | None = None, res_mix: torch.Tensor | None = None, residual: torch.Tensor | None = None, ) -> tuple[ torch.Tensor, torch.Tensor | None, torch.Tensor | None, torch.Tensor | None ]: if residual is None: # First layer: run standalone hc_pre residual = x x, post_mix, res_mix = self.hc_pre( x, self.hc_attn_fn, self.hc_attn_scale, self.hc_attn_base ) else: residual, post_mix, res_mix, x = self.mhc_fused_post_pre( x, residual, post_mix, res_mix, self.hc_attn_fn, self.hc_attn_scale, self.hc_attn_base, self.rms_norm_eps, self.hc_eps, self.hc_eps, self.hc_post_alpha, self.hc_sinkhorn_iters, ) x = self.attn_norm(x) x = self.attn(positions, x, None) residual, post_mix, res_mix, x = self.mhc_fused_post_pre( x, residual, post_mix, res_mix, self.hc_ffn_fn, self.hc_ffn_scale, self.hc_ffn_base, self.rms_norm_eps, self.hc_eps, self.hc_eps, self.hc_post_alpha, self.hc_sinkhorn_iters, ) x = self.ffn_norm(x) x = self.ffn(x, input_ids) return x, residual, post_mix, res_mix class DeepseekV4Model(nn.Module, EagleModelMixin): def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""): super().__init__() config = vllm_config.model_config.hf_config quant_config = vllm_config.quant_config self.config = config self.use_mega_moe = ( vllm_config.kernel_config.moe_backend == "deep_gemm_mega_moe" ) if self.use_mega_moe and not vllm_config.parallel_config.enable_expert_parallel: raise NotImplementedError( "DeepSeek V4 MegaMoE currently requires expert parallel. " "Enable it with --enable-expert-parallel, or pick a different " "moe backend." ) self.vocab_size = config.vocab_size self.hc_eps = config.hc_eps self.hc_mult = config.hc_mult self.hc_dim = self.hc_mult * config.hidden_size self.rms_norm_eps = config.rms_norm_eps # Disable aux streams on XPU — no multi-stream overlap support. aux_stream_list = None self.device = current_platform.device_type # Reserved topk indices buffer for all Indexer layers to reuse. self.topk_indices_buffer = torch.empty( vllm_config.scheduler_config.max_num_batched_tokens, config.index_topk, dtype=torch.int32, device=self.device, ) if get_pp_group().is_first_rank: self.embed_tokens = VocabParallelEmbedding( config.vocab_size, config.hidden_size, quant_config=quant_config, prefix=f"{prefix}.embed_tokens", ) else: self.embed_tokens = PPMissingLayer() self.start_layer, self.end_layer, self.layers = make_layers( config.num_hidden_layers, lambda prefix: DeepseekV4DecoderLayer( vllm_config, prefix=prefix, topk_indices_buffer=self.topk_indices_buffer, aux_stream_list=aux_stream_list, ), prefix=f"{prefix}.layers", ) if get_pp_group().is_last_rank: self.norm = RMSNorm(config.hidden_size, self.rms_norm_eps) else: self.norm = PPMissingLayer() self.hc_head_fn = nn.Parameter( torch.empty( self.hc_mult, self.hc_dim, dtype=torch.float32, ), requires_grad=False, ) self.hc_head_base = nn.Parameter( torch.empty( self.hc_mult, dtype=torch.float32, ), requires_grad=False, ) self.hc_head_scale = nn.Parameter( torch.empty(1, dtype=torch.float32), requires_grad=False, ) self.hc_head_op = HCHeadOp() spec_config = vllm_config.speculative_config needs_mtp_hidden_states = spec_config is not None and ( spec_config.use_eagle() or spec_config.uses_draft_model() ) if get_pp_group().is_last_rank and needs_mtp_hidden_states: self._mtp_hidden_buffer = torch.empty( vllm_config.scheduler_config.max_num_batched_tokens, self.hc_dim, dtype=vllm_config.model_config.dtype, device=self.device, ) else: self._mtp_hidden_buffer = None def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor: return self.embed_tokens(input_ids) def make_empty_intermediate_tensors( self, batch_size: int, dtype: torch.dtype, device: torch.device, ) -> IntermediateTensors: # PP intermediate tensors carry the multi-stream hidden_states # of shape (num_tokens, hc_mult, hidden_size) — V4 expands the # token embedding to hc_mult streams before the first decoder # layer and keeps that shape until hc_head() collapses it. return IntermediateTensors( { "hidden_states": torch.zeros( (batch_size, self.hc_mult, self.config.hidden_size), dtype=dtype, device=device, ), } ) def forward( self, input_ids: torch.Tensor, positions: torch.Tensor, intermediate_tensors: IntermediateTensors | None, inputs_embeds: torch.Tensor | None = None, ) -> torch.Tensor | IntermediateTensors: if get_pp_group().is_first_rank: if inputs_embeds is not None: hidden_states = inputs_embeds else: hidden_states = self.embed_input_ids(input_ids) hidden_states = hidden_states.unsqueeze(-2).repeat(1, self.hc_mult, 1) else: assert intermediate_tensors is not None hidden_states = intermediate_tensors["hidden_states"] if self.use_mega_moe: input_ids = input_ids.to(torch.int64) residual, post_mix, res_mix = None, None, None aux_hidden_states: list[torch.Tensor] = [] for idx, layer in enumerate( islice(self.layers, self.start_layer, self.end_layer), start=self.start_layer, ): hidden_states, residual, post_mix, res_mix = layer( hidden_states, positions, input_ids, post_mix, res_mix, residual, ) if idx + 1 in self.aux_hidden_state_layers: aux_recon = layer.hc_post(hidden_states, residual, post_mix, res_mix) aux_hidden_states.append(aux_recon.mean(dim=1)) # The fused path defers the final hc_post to the next layer's # fused_post_pre. After the last layer we must apply it explicitly. if layer is not None: hidden_states = layer.hc_post(hidden_states, residual, post_mix, res_mix) if not get_pp_group().is_last_rank: return IntermediateTensors({"hidden_states": hidden_states}) if self._mtp_hidden_buffer is not None: num_tokens = hidden_states.shape[0] self._mtp_hidden_buffer[:num_tokens].copy_(hidden_states.flatten(1)) hidden_states = self.hc_head_op( hidden_states, self.hc_head_fn, self.hc_head_scale, self.hc_head_base, self.rms_norm_eps, self.hc_eps, ) hidden_states = self.norm(hidden_states) if len(aux_hidden_states) > 0: return hidden_states, aux_hidden_states return hidden_states def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]: stacked_params_mapping = [ # (param_name, shard_name, shard_id) ("gate_up_proj", "w1", 0), ("gate_up_proj", "w3", 1), ("attn.fused_wqa_wkv", "attn.wq_a", 0), ("attn.fused_wqa_wkv", "attn.wkv", 1), ("compressor.fused_wkv_wgate", "compressor.wkv", 0), ("compressor.fused_wkv_wgate", "compressor.wgate", 1), ] params_dict = dict(self.named_parameters()) loaded_params: set[str] = set() # Pre-compute expert mapping ONCE. expert_mapping = self.get_expert_mapping() for name, loaded_weight in weights: for param_name, weight_name, shard_id in stacked_params_mapping: # Skip non-stacked layers and experts (experts handled below). if ".experts." in name: continue if weight_name not in name: continue name = name.replace(weight_name, param_name) if is_pp_missing_parameter(name, self): break if name not in params_dict: head, _, leaf = name.rpartition(".") suffixed = f"{head}.base_layer.{leaf}" if suffixed in params_dict: name = suffixed param = params_dict[name] weight_loader = param.weight_loader weight_loader(param, loaded_weight, shard_id) loaded_params.add(name) break else: if ".experts." in name: # E8M0 scales are stored as float8_e8m0fnu in # checkpoints but the MoE param is uint8. copy_() # would do a numeric conversion (e.g. 2^-7 → 0), # destroying the raw exponent bytes. if ( "weight_scale" in name and loaded_weight.dtype == torch.float8_e8m0fnu ): loaded_weight = loaded_weight.view(torch.uint8) for mapping in expert_mapping: param_name, weight_name, expert_id, expert_shard_id = mapping if weight_name not in name: continue name_mapped = name.replace(weight_name, param_name) if is_pp_missing_parameter(name_mapped, self): continue param = params_dict[name_mapped] # We should ask the weight loader to return success or not # here since otherwise we may skip experts with other # available replicas. weight_loader = typing.cast( Callable[..., bool], param.weight_loader ) success = weight_loader( param, loaded_weight, name_mapped, shard_id=expert_shard_id, expert_id=expert_id, return_success=True, ) if success: name = name_mapped break loaded_params.add(name_mapped) continue else: if is_pp_missing_parameter(name, self): continue # Non-LoRA params on a LoRA-wrapped module live at # ``.base_layer.``; the checkpoint is plain. if name not in params_dict: head, _, leaf = name.rpartition(".") suffixed = f"{head}.base_layer.{leaf}" if suffixed in params_dict: name = suffixed param = params_dict[name] weight_loader = getattr( param, "weight_loader", default_weight_loader ) weight_loader(param, loaded_weight) loaded_params.add(name) continue return loaded_params def get_expert_mapping(self) -> list[tuple[str, str, int, str]]: first_layer = next(iter(islice(self.layers, self.start_layer, self.end_layer))) if first_layer.ffn.use_mega_moe: return make_deepseek_v4_expert_params_mapping(self.config.n_routed_experts) # Params for weights, fp8 weight scales, fp8 activation scales # (param_name, weight_name, expert_id, shard_id) return fused_moe_make_expert_params_mapping( self, ckpt_gate_proj_name="w1", ckpt_down_proj_name="w2", ckpt_up_proj_name="w3", num_experts=self.config.n_routed_experts, ) def finalize_mega_moe_weights(self) -> None: for layer in islice(self.layers, self.start_layer, self.end_layer): layer.ffn.finalize_mega_moe_weights() def _make_deepseek_v4_weights_mapper(expert_dtype: str) -> WeightsMapper: if expert_dtype == "fp4": # MXFP4 experts use Mxfp4MoEMethod, which registers scales as # ``w{1,2,3}_weight_scale`` (no _inv suffix). FP8 linear and # shared experts use Fp8LinearMethod's block scales, which # register as ``weight_scale_inv``. scale_regex = { # ``.base_layer.``-namespace variant (LoRA-wrapped experts). re.compile( r"(\.experts\.\d+\.w[123]\.base_layer)\.scale$" ): r"\1.weight_scale", re.compile(r"(\.experts\.\d+\.w[123])\.scale$"): r"\1.weight_scale", re.compile(r"\.scale$"): ".weight_scale_inv", } else: # FP8 experts use Fp8MoEMethod (block_quant=True), which registers # scales as ``w{13,2}_weight_scale_inv``. Map all ``.scale`` keys # there. scale_regex = { # ``.base_layer.``-namespace variant of the above. re.compile( r"(\.experts\.\d+\.w[123]\.base_layer)\.scale$" ): r"\1.weight_scale_inv", re.compile(r"\.scale$"): ".weight_scale_inv", } return WeightsMapper( orig_to_new_prefix={ "layers.": "model.layers.", "embed.": "model.embed.", "norm.": "model.norm.", "hc_head": "model.hc_head", "mtp.": "model.mtp.", }, orig_to_new_regex=scale_regex, orig_to_new_suffix={ "head.weight": "lm_head.weight", "embed.weight": "embed_tokens.weight", ".ffn.gate.bias": ".ffn.gate.e_score_correction_bias", }, orig_to_new_substr={ ".shared_experts.w2": ".shared_experts.down_proj", "mtp.": None, }, ) class DeepseekV4ForCausalLM(nn.Module, SupportsPP, SupportsEagle3, SupportsLoRA): model_cls = DeepseekV4Model # Default mapper assumes the original FP4-expert checkpoint layout. # Overridden per-instance in __init__ when expert_dtype != "fp4". hf_to_vllm_mapper = _make_deepseek_v4_weights_mapper("fp4") packed_modules_mapping = { "gate_up_proj": ["w1", "w3"], "fused_wqa_wkv": ["wq_a", "wkv"], "fused_wkv_wgate": ["wkv", "wgate"], } # The MTP draft head is not LoRA-adapted. lora_skip_prefixes = ["mtp."] def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""): super().__init__() config = vllm_config.model_config.hf_config self.config = config expert_dtype = getattr(config, "expert_dtype", "fp4") if expert_dtype != "fp4": self.hf_to_vllm_mapper = _make_deepseek_v4_weights_mapper(expert_dtype) self.model = self.model_cls( vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model") ) if get_pp_group().is_last_rank: self.lm_head = ParallelLMHead( config.vocab_size, config.hidden_size, prefix=maybe_prefix(prefix, "lm_head"), ) else: self.lm_head = PPMissingLayer() self.logits_processor = LogitsProcessor(config.vocab_size) self.make_empty_intermediate_tensors = ( # type: ignore[method-assign] self.model.make_empty_intermediate_tensors ) def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor: return self.model.embed_input_ids(input_ids) def compute_logits( self, hidden_states: torch.Tensor, ) -> torch.Tensor | None: logits = self.logits_processor(self.lm_head, hidden_states) return logits def forward( self, input_ids: torch.Tensor, positions: torch.Tensor, intermediate_tensors: IntermediateTensors | None = None, inputs_embeds: torch.Tensor | None = None, ) -> torch.Tensor | IntermediateTensors: hidden_states = self.model( input_ids, positions, intermediate_tensors, inputs_embeds ) return hidden_states def get_mtp_target_hidden_states(self) -> torch.Tensor | None: """Pre-hc_head residual stream buffer (max_num_batched_tokens, hc_mult * hidden_size) for the MTP draft model. Populated by forward(); valid after each target step.""" return getattr(self.model, "_mtp_hidden_buffer", None) def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]: loader = AutoWeightsLoader(self) loaded_params = loader.load_weights(weights, mapper=self.hf_to_vllm_mapper) self.model.finalize_mega_moe_weights() return loaded_params def get_expert_mapping(self) -> list[tuple[str, str, int, str]]: return self.model.get_expert_mapping()