[Refactor] Delete dead code in models (#51838)
Signed-off-by: yewentao256 <zhyanwentao@126.com>
Wentao Ye committed
Aug 11, 2026 at 15:44 UTC
fd04edef3e62c8dec19cddd76253c0fc6d56ab62
25 files changed
+34
-223
vllm/lora/layers/fused_moe.py
-4
@@ -466,10 +466,6 @@ class FusedMoEWithLoRA(BaseLayerWithLoRA):
466
def runner(self) -> MoERunner:
467
return self.base_layer
468
469
- @property
470
- def is_internal_router(self) -> bool:
471
- return self.base_layer.is_internal_router
472
-
469
@classmethod
470
def can_replace_layer(
471
cls,
vllm/model_executor/layers/fused_moe/runner/moe_runner.py
-4
@@ -311,10 +311,6 @@ class MoERunner(MoERunnerInterface):
311
def shared_experts(self) -> SharedExperts | None:
312
return self._shared_experts
313
314
- @property
315
- def is_internal_router(self) -> bool:
316
- return self.gate is not None
317
-
314
# TODO(bnell): Temporary hack. Get rid of this.
315
def _replace_quant_method(self, quant_method: FusedMoEMethodBase):
316
self.routed_experts._replace_quant_method(quant_method)
vllm/model_executor/layers/fused_moe/runner/moe_runner_interface.py
-5
@@ -45,11 +45,6 @@ class MoERunnerInterface(PluggableLayer, ABC):
45
def shared_experts(self) -> SharedExperts | None:
46
raise NotImplementedError
47
48
- @property
49
- @abstractmethod
50
- def is_internal_router(self) -> bool:
51
- raise NotImplementedError
52
-
48
@property
49
@abstractmethod
50
def _quant_method(self) -> FusedMoEMethodBase:
vllm/model_executor/models/AXK1.py
+3
-15
@@ -108,7 +108,6 @@ class AXK1MoE(nn.Module):
108
self.routed_scaling_factor = getattr(config, "routed_scaling_factor", 1.0)
109
110
self.ep_group = get_ep_group().device_group
111
- self.ep_rank = get_ep_group().rank_in_group
111
self.ep_size = self.ep_group.size()
112
assert config.n_routed_experts is not None
113
assert config.num_experts_per_tok is not None
@@ -148,11 +147,6 @@ class AXK1MoE(nn.Module):
147
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
148
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
149
151
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
152
- self.physical_expert_end = (
153
- self.physical_expert_start + self.n_local_physical_experts
154
- )
155
-
150
self.is_rocm_aiter_moe_enabled = rocm_aiter_ops.is_fused_moe_enabled()
151
self.is_fusion_moe_shared_experts_enabled = (
152
rocm_aiter_ops.is_fusion_moe_shared_experts_enabled()
@@ -210,15 +204,9 @@ class AXK1MoE(nn.Module):
204
if self.is_sequence_parallel:
205
hidden_states = sequence_parallel_chunk(hidden_states)
206
213
- if self.experts.is_internal_router:
214
- final_hidden_states = self.experts(
215
- hidden_states=hidden_states, router_logits=hidden_states
216
- )
217
- else:
218
- router_logits, _ = self.gate(hidden_states)
219
- final_hidden_states = self.experts(
220
- hidden_states=hidden_states, router_logits=router_logits
221
- )
207
+ final_hidden_states = self.experts(
208
+ hidden_states=hidden_states, router_logits=hidden_states
209
+ )
210
211
if self.is_sequence_parallel:
212
final_hidden_states = tensor_model_parallel_all_gather(
vllm/model_executor/models/afmoe.py
-6
@@ -71,7 +71,6 @@ class AfmoeMoE(nn.Module):
71
self.route_norm = config.route_norm
72
73
self.ep_group = get_ep_group().device_group
74
- self.ep_rank = self.ep_group.rank()
74
self.ep_size = self.ep_group.size()
75
self.n_routed_experts: int = config.num_experts
76
self.n_shared_experts: int = config.num_shared_experts
@@ -103,11 +102,6 @@ class AfmoeMoE(nn.Module):
102
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
103
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
104
106
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
107
- self.physical_expert_end = (
108
- self.physical_expert_start + self.n_local_physical_experts
109
- )
110
-
105
self.shared_experts = None
106
# Shared experts
107
if config.num_shared_experts > 0:
vllm/model_executor/models/deepseek_v2.py
+3
-15
@@ -293,7 +293,6 @@ class DeepseekV2MoE(nn.Module):
293
self.routed_scaling_factor = getattr(config, "routed_scaling_factor", 1.0)
294
295
self.ep_group = get_ep_group().device_group
296
- self.ep_rank = get_ep_group().rank_in_group
296
self.ep_size = self.ep_group.size()
297
self.n_routed_experts: int = config.n_routed_experts
298
self.n_shared_experts: int = config.n_shared_experts
@@ -329,11 +328,6 @@ class DeepseekV2MoE(nn.Module):
328
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
329
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
330
332
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
333
- self.physical_expert_end = (
334
- self.physical_expert_start + self.n_local_physical_experts
335
- )
336
-
331
self.is_rocm_aiter_moe_enabled = rocm_aiter_ops.is_fused_moe_enabled()
332
self.is_fusion_moe_shared_experts_enabled = (
333
rocm_aiter_ops.is_fusion_moe_shared_experts_enabled()
@@ -409,15 +403,9 @@ class DeepseekV2MoE(nn.Module):
403
if self.is_sequence_parallel and not already_sequence_parallel:
404
hidden_states = sequence_parallel_chunk(hidden_states)
405
412
- if self.experts.is_internal_router:
413
- final_hidden_states = self.experts(
414
- hidden_states=hidden_states, router_logits=hidden_states
415
- )
416
- else:
417
- router_logits, _ = self.gate(hidden_states)
418
- final_hidden_states = self.experts(
419
- hidden_states=hidden_states, router_logits=router_logits
420
- )
406
+ final_hidden_states = self.experts(
407
+ hidden_states=hidden_states, router_logits=hidden_states
408
+ )
409
410
if self.is_sequence_parallel and not already_sequence_parallel:
411
final_hidden_states = tensor_model_parallel_all_gather(
vllm/model_executor/models/ernie45_moe.py
-5
@@ -129,7 +129,6 @@ class Ernie4_5_MoeMoE(nn.Module):
129
130
self.moe_num_shared_experts = getattr(config, "moe_num_shared_experts", None)
131
self.ep_group = get_ep_group().device_group
132
- self.ep_rank = get_ep_group().rank_in_group
132
self.ep_size = self.ep_group.size()
133
self.n_routed_experts: int = config.moe_num_experts
134
self.n_shared_experts: int = self.moe_num_shared_experts
@@ -143,10 +142,6 @@ class Ernie4_5_MoeMoE(nn.Module):
142
self.n_logical_experts = self.n_routed_experts
143
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
144
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
146
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
147
- self.physical_expert_end = (
148
- self.physical_expert_start + self.n_local_physical_experts
149
- )
145
self.has_shared_experts = getattr(config, "moe_num_shared_experts", 0) > 0
146
147
if self.tp_size > config.moe_num_experts:
vllm/model_executor/models/exaone_moe.py
-6
@@ -76,7 +76,6 @@ class ExaoneMoe(nn.Module):
76
self.routed_scaling_factor = config.routed_scaling_factor
77
78
self.ep_group = get_ep_group().device_group
79
- self.ep_rank = self.ep_group.rank()
79
self.ep_size = self.ep_group.size()
80
self.n_routed_experts = config.num_experts
81
@@ -113,11 +112,6 @@ class ExaoneMoe(nn.Module):
112
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
113
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
114
116
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
117
- self.physical_expert_end = (
118
- self.physical_expert_start + self.n_local_physical_experts
119
- )
120
-
115
if getattr(config, "num_shared_experts", 0) > 0:
116
intermediate_size = config.moe_intermediate_size * config.num_shared_experts
117
self.shared_experts = ExaoneMoeGatedMLP(
vllm/model_executor/models/glm4_moe.py
-6
@@ -127,7 +127,6 @@ class Glm4MoE(nn.Module):
127
self.routed_scaling_factor = config.routed_scaling_factor
128
129
self.ep_group = get_ep_group().device_group
130
- self.ep_rank = get_ep_group().rank_in_group
130
self.ep_size = self.ep_group.size()
131
self.n_routed_experts: int = config.n_routed_experts
132
self.n_shared_experts: int = config.n_shared_experts
@@ -160,11 +159,6 @@ class Glm4MoE(nn.Module):
159
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
160
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
161
163
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
164
- self.physical_expert_end = (
165
- self.physical_expert_start + self.n_local_physical_experts
166
- )
167
-
162
# AITER fused shared-expert (FSE) gate; mirrors the deepseek_v2.py
163
# pattern (see Glm4MoE / MoERunner wiring there).
164
self.is_rocm_aiter_moe_enabled = rocm_aiter_ops.is_fused_moe_enabled()
vllm/model_executor/models/hunyuan_v1.py
-6
@@ -372,7 +372,6 @@ class HunYuanSparseMoeBlock(nn.Module):
372
self.tp_size = get_tensor_model_parallel_world_size()
373
374
self.ep_group = get_ep_group().device_group
375
- self.ep_rank = get_ep_group().rank_in_group
375
self.ep_size = self.ep_group.size()
376
self.n_routed_experts = config.num_experts
377
@@ -408,11 +407,6 @@ class HunYuanSparseMoeBlock(nn.Module):
407
self.n_redundant_experts = eplb_config.num_redundant_experts
408
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
409
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
411
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
412
- self.physical_expert_end = (
413
- self.physical_expert_start + self.n_local_physical_experts
414
- )
415
-
410
self.gate = ReplicatedLinear(
411
config.hidden_size,
412
config.num_experts,
vllm/model_executor/models/hy_v3.py
-5
@@ -134,7 +134,6 @@ class HYV3MoEFused(nn.Module):
134
super().__init__()
135
self.tp_size = get_tensor_model_parallel_world_size()
136
self.ep_group = get_ep_group().device_group
137
- self.ep_rank = get_ep_group().rank_in_group
137
self.ep_size = self.ep_group.size()
138
self.n_routed_experts = config.num_experts
139
if self.tp_size > config.num_experts:
@@ -153,10 +152,6 @@ class HYV3MoEFused(nn.Module):
152
self.n_redundant_experts = eplb_config.num_redundant_experts
153
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
154
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
156
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
157
- self.physical_expert_end = (
158
- self.physical_expert_start + self.n_local_physical_experts
159
- )
155
self.gate = GateLinear(
156
config.hidden_size,
157
config.num_experts,
vllm/model_executor/models/interns1_pro.py
-6
@@ -144,7 +144,6 @@ class InternS1ProMoeSparseMoeBlock(nn.Module):
144
self.tp_size = get_tensor_model_parallel_world_size()
145
146
self.ep_group = get_ep_group().device_group
147
- self.ep_rank = get_ep_group().rank_in_group
147
self.ep_size = self.ep_group.size()
148
self.n_routed_experts = config.num_experts
149
@@ -165,11 +164,6 @@ class InternS1ProMoeSparseMoeBlock(nn.Module):
164
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
165
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
166
168
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
169
- self.physical_expert_end = (
170
- self.physical_expert_start + self.n_local_physical_experts
171
- )
172
-
167
# For custom routing function
168
self.n_groups = getattr(config, "router_n_groups", -1)
169
vllm/model_executor/models/interns2_mobius.py
+4
-11
@@ -127,17 +127,10 @@ class InternS2MobiusMetaMoeBlock(nn.Module):
127
if self.is_sequence_parallel and not already_sequence_parallel:
128
hidden_states = sequence_parallel_chunk(hidden_states)
129
130
- if self.experts.is_internal_router:
131
- final_hidden_states = self.experts(
132
- hidden_states=hidden_states,
133
- router_logits=hidden_states,
134
- )
135
- else:
136
- router_logits, _ = self.gate(hidden_states)
137
- final_hidden_states = self.experts(
138
- hidden_states=hidden_states,
139
- router_logits=router_logits,
140
- )
130
+ final_hidden_states = self.experts(
131
+ hidden_states=hidden_states,
132
+ router_logits=hidden_states,
133
+ )
134
135
if self.is_sequence_parallel and not already_sequence_parallel:
136
final_hidden_states = tensor_model_parallel_all_gather(
vllm/model_executor/models/laguna.py
-6
@@ -132,7 +132,6 @@ class LagunaMoE(nn.Module):
132
133
self.tp_size = get_tensor_model_parallel_world_size()
134
self.ep_group = get_ep_group().device_group
135
- self.ep_rank = self.ep_group.rank()
135
self.ep_size = self.ep_group.size()
136
137
self.n_routed_experts = config.num_experts
@@ -160,11 +159,6 @@ class LagunaMoE(nn.Module):
159
self.n_logical_experts = self.n_routed_experts
160
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
161
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
163
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
164
- self.physical_expert_end = (
165
- self.physical_expert_start + self.n_local_physical_experts
166
- )
167
-
162
# Router gate
163
self.gate = ReplicatedLinear(
164
config.hidden_size,
vllm/model_executor/models/lfm2_moe.py
-6
@@ -106,7 +106,6 @@ class Lfm2MoeSparseMoeBlock(nn.Module):
106
self.routed_scaling_factor = config.routed_scaling_factor
107
108
self.ep_group = get_ep_group().device_group
109
- self.ep_rank = get_ep_group().rank_in_group
109
self.ep_size = self.ep_group.size()
110
self.n_routed_experts = config.num_experts
111
@@ -126,11 +125,6 @@ class Lfm2MoeSparseMoeBlock(nn.Module):
125
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
126
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
127
129
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
130
- self.physical_expert_end = (
131
- self.physical_expert_start + self.n_local_physical_experts
132
- )
133
-
128
self.gate = ReplicatedLinear(
129
config.hidden_size,
130
config.num_experts,
vllm/model_executor/models/mimo_v2.py
-6
@@ -127,7 +127,6 @@ class MiMoV2MoE(nn.Module):
127
self.tp_size = get_tensor_model_parallel_world_size()
128
129
self.ep_group = get_ep_group().device_group
130
- self.ep_rank = get_ep_group().rank_in_group
130
self.ep_size = self.ep_group.size()
131
self.n_routed_experts = config.n_routed_experts
132
@@ -154,11 +153,6 @@ class MiMoV2MoE(nn.Module):
153
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
154
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
155
157
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
158
- self.physical_expert_end = (
159
- self.physical_expert_start + self.n_local_physical_experts
160
- )
161
-
156
dtype = getattr(config, "moe_router_dtype", "float32")
157
self.gate_dtype = str_dtype_to_torch_dtype(dtype)
158
self.gate = nn.Linear(
vllm/model_executor/models/mixtral.py
-6
@@ -92,7 +92,6 @@ class MixtralMoE(nn.Module):
92
self.hidden_size = hidden_size
93
94
self.ep_group = get_ep_group().device_group
95
- self.ep_rank = get_ep_group().rank_in_group
95
self.ep_size = self.ep_group.size()
96
97
# Expert Parallelism Load balancing settings.
@@ -105,11 +104,6 @@ class MixtralMoE(nn.Module):
104
self.n_redundant_experts = parallel_config.eplb_config.num_redundant_experts
105
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
106
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
108
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
109
- self.physical_expert_end = (
110
- self.physical_expert_start + self.n_local_physical_experts
111
- )
112
-
107
# Gate always runs at half / full precision for now.
108
109
self.gate = ReplicatedLinear(
vllm/model_executor/models/nemotron_h.py
-6
@@ -136,7 +136,6 @@ class NemotronHMoE(nn.Module):
136
self.routed_scaling_factor = config.routed_scaling_factor
137
138
self.ep_group = get_ep_group().device_group
139
- self.ep_rank = self.ep_group.rank()
139
self.ep_size = self.ep_group.size()
140
self.n_routed_experts: int = config.n_routed_experts
141
self.n_shared_experts: int = config.n_shared_experts
@@ -166,11 +165,6 @@ class NemotronHMoE(nn.Module):
165
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
166
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
167
169
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
170
- self.physical_expert_end = (
171
- self.physical_expert_start + self.n_local_physical_experts
172
- )
173
-
168
if config.n_shared_experts is None or config.n_shared_experts == 0:
169
self.shared_experts = None
170
else:
vllm/model_executor/models/openpangu.py
-6
@@ -142,7 +142,6 @@ class OpenPanguMoE(nn.Module):
142
143
self.routed_scaling_factor = config.routed_scaling_factor
144
self.ep_group = get_ep_group().device_group
145
- self.ep_rank = self.ep_group.rank()
145
self.ep_size = self.ep_group.size()
146
self.n_routed_experts: int = config.n_routed_experts
147
self.n_shared_experts: int = config.n_shared_experts
@@ -176,11 +175,6 @@ class OpenPanguMoE(nn.Module):
175
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
176
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
177
179
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
180
- self.physical_expert_end = (
181
- self.physical_expert_start + self.n_local_physical_experts
182
- )
183
-
178
if config.n_shared_experts is not None:
179
intermediate_size = config.moe_intermediate_size * config.n_shared_experts
180
self.shared_experts = OpenPanguMLP(
vllm/model_executor/models/qwen3_moe.py
+3
-19
@@ -142,7 +142,6 @@ class Qwen3MoeSparseMoeBlock(nn.Module):
142
self.tp_size = get_tensor_model_parallel_world_size()
143
144
self.ep_group = get_ep_group().device_group
145
- self.ep_rank = get_ep_group().rank_in_group
145
self.ep_size = self.ep_group.size()
146
self.n_routed_experts = config.num_experts
147
@@ -164,11 +163,6 @@ class Qwen3MoeSparseMoeBlock(nn.Module):
163
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
164
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
165
167
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
168
- self.physical_expert_end = (
169
- self.physical_expert_start + self.n_local_physical_experts
170
- )
171
-
166
self.gate = ReplicatedLinear(
167
config.hidden_size,
168
config.num_experts,
@@ -227,19 +221,9 @@ class Qwen3MoeSparseMoeBlock(nn.Module):
221
if self.is_sequence_parallel:
222
hidden_states = sequence_parallel_chunk(hidden_states)
223
230
- if self.experts.is_internal_router:
231
- # In this case, the gate/router runs inside the MoERunner class
232
- final_hidden_states = self.experts(
233
- hidden_states=hidden_states, router_logits=hidden_states
234
- )
235
- else:
236
- # Actually this will be dead code, since we always pass gate into
237
- # MoERunner in the current implementation. But we keep this code
238
- # here for clarity and future flexibility.
239
- router_logits, _ = self.gate(hidden_states)
240
- final_hidden_states = self.experts(
241
- hidden_states=hidden_states, router_logits=router_logits
242
- )
224
+ final_hidden_states = self.experts(
225
+ hidden_states=hidden_states, router_logits=hidden_states
226
+ )
227
228
if self.is_sequence_parallel:
229
final_hidden_states = tensor_model_parallel_all_gather(
vllm/model_executor/models/qwen3_next.py
+3
-17
@@ -109,7 +109,6 @@ class Qwen3NextSparseMoeBlock(nn.Module):
109
self.tp_size = get_tensor_model_parallel_world_size()
110
111
self.ep_group = get_ep_group().device_group
112
- self.ep_rank = get_ep_group().rank_in_group
112
self.ep_size = self.ep_group.size()
113
self.n_routed_experts = config.num_experts
114
@@ -130,11 +129,6 @@ class Qwen3NextSparseMoeBlock(nn.Module):
129
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
130
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
131
133
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
134
- self.physical_expert_end = (
135
- self.physical_expert_start + self.n_local_physical_experts
136
- )
137
-
132
self.gate = ReplicatedLinear(
133
config.hidden_size,
134
config.num_experts,
@@ -205,17 +199,9 @@ class Qwen3NextSparseMoeBlock(nn.Module):
199
if self.is_sequence_parallel and not already_sequence_parallel:
200
hidden_states = sequence_parallel_chunk(hidden_states)
201
208
- if self.experts.is_internal_router:
209
- # In this case, the gate/router runs inside the MoERunner class
210
- final_hidden_states = self.experts(
211
- hidden_states=hidden_states, router_logits=hidden_states
212
- )
213
- else:
214
- # router_logits: (num_tokens, n_experts)
215
- router_logits, _ = self.gate(hidden_states)
216
- final_hidden_states = self.experts(
217
- hidden_states=hidden_states, router_logits=router_logits
218
- )
202
+ final_hidden_states = self.experts(
203
+ hidden_states=hidden_states, router_logits=hidden_states
204
+ )
205
206
if self.is_sequence_parallel and not already_sequence_parallel:
207
final_hidden_states = tensor_model_parallel_all_gather(
vllm/model_executor/models/step3p5.py
+3
-16
@@ -303,7 +303,6 @@ class FusedMoEBlock(nn.Module):
303
self.layer_idx = extract_layer_index(prefix)
304
305
self.ep_size = get_ep_group().device_group.size()
306
- self.ep_rank = get_ep_group().device_group.rank()
306
config = vllm_config.model_config.hf_config
307
quant_config = vllm_config.quant_config
308
parallel_config = vllm_config.parallel_config
@@ -316,11 +315,6 @@ class FusedMoEBlock(nn.Module):
315
self.n_physical_experts = self.n_logical_experts + self.n_redundant_experts
316
self.n_local_physical_experts = self.n_physical_experts // self.ep_size
317
319
- self.physical_expert_start = self.ep_rank * self.n_local_physical_experts
320
- self.physical_expert_end = (
321
- self.physical_expert_start + self.n_local_physical_experts
322
- )
323
-
318
if self.tp_size > config.moe_num_experts:
319
raise ValueError(
320
f"Tensor parallel size {self.tp_size} is greater than "
@@ -399,16 +393,9 @@ class FusedMoEBlock(nn.Module):
393
num_tokens, hidden_dim = hidden_states.shape
394
hidden_states = hidden_states.view(-1, hidden_dim)
395
402
- if self.experts.is_internal_router:
403
- final_hidden_states = self.experts(
404
- hidden_states=hidden_states, router_logits=hidden_states
405
- )
406
- else:
407
- # TODO(bnell): this gate could be moved into the MoERunner?
408
- router_logits, _ = self.gate(hidden_states)
409
- final_hidden_states = self.experts(
410
- hidden_states=hidden_states, router_logits=router_logits
411
- )
396
+ final_hidden_states = self.experts(
397
+ hidden_states=hidden_states, router_logits=hidden_states
398
+ )
399
400
return final_hidden_states.view(num_tokens, hidden_dim)
401
vllm/models/deepseek_v4/amd/model.py
+5
-14
@@ -307,20 +307,11 @@ class DeepseekV4MoE(nn.Module):
307
raise ValueError("DeepSeek V4 hash MoE routing requires input_ids.")
308
309
org_shape = hidden_states.shape
310
- if self.experts.is_internal_router:
311
- # In this case, the gate/router runs inside the MoERunner class
312
- final_hidden_states = self.experts(
313
- hidden_states=hidden_states,
314
- router_logits=hidden_states,
315
- input_ids=input_ids,
316
- )
317
- else:
318
- router_logits, _ = self.gate(hidden_states)
319
- final_hidden_states = self.experts(
320
- hidden_states=hidden_states,
321
- router_logits=router_logits,
322
- input_ids=input_ids,
323
- )
310
+ final_hidden_states = self.experts(
311
+ hidden_states=hidden_states,
312
+ router_logits=hidden_states,
313
+ input_ids=input_ids,
314
+ )
315
316
return final_hidden_states.view(org_shape)
317
vllm/models/deepseek_v4/nvidia/model.py
+5
-14
@@ -746,20 +746,11 @@ class DeepseekV4MoE(nn.Module):
746
self, hidden_states: torch.Tensor, input_ids: torch.Tensor | None = None
747
) -> torch.Tensor:
748
org_shape = hidden_states.shape
749
- if self.experts.is_internal_router:
750
- # In this case, the gate/router runs inside the MoERunner class
751
- final_hidden_states = self.experts(
752
- hidden_states=hidden_states,
753
- router_logits=hidden_states,
754
- input_ids=input_ids,
755
- )
756
- else:
757
- router_logits, _ = self.gate(hidden_states)
758
- final_hidden_states = self.experts(
759
- hidden_states=hidden_states,
760
- router_logits=router_logits,
761
- input_ids=input_ids,
762
- )
749
+ final_hidden_states = self.experts(
750
+ hidden_states=hidden_states,
751
+ router_logits=hidden_states,
752
+ input_ids=input_ids,
753
+ )
754
755
return final_hidden_states.view(org_shape)
756
vllm/models/deepseek_v4/xpu/model.py
+5
-13
@@ -792,19 +792,11 @@ class DeepseekV4MoE(nn.Module):
792
self, hidden_states: torch.Tensor, input_ids: torch.Tensor | None = None
793
) -> torch.Tensor:
794
org_shape = hidden_states.shape
795
- if self.experts.is_internal_router:
796
- final_hidden_states = self.experts(
797
- hidden_states=hidden_states,
798
- router_logits=hidden_states,
799
- input_ids=input_ids,
800
- )
801
- else:
802
- router_logits, _ = self.gate(hidden_states)
803
- final_hidden_states = self.experts(
804
- hidden_states=hidden_states,
805
- router_logits=router_logits,
806
- input_ids=input_ids,
807
- )
795
+ final_hidden_states = self.experts(
796
+ hidden_states=hidden_states,
797
+ router_logits=hidden_states,
798
+ input_ids=input_ids,
799
+ )
800
801
return final_hidden_states.view(org_shape)
802