Upload 2 files

patches/qwen3_5.py.patch.md

@@ -0,0 +1,56 @@
+# vLLM Patch: qwen3_5.py — Tensor shape-based expert count in weight loading
+
+**File:** `vllm/model_executor/models/qwen3_5.py`
+**Class:** `Qwen3_5Model.load_weights`
+**Tested on:** vLLM 0.16.1rc1.dev188
+
+## What it does
+
+When loading fused expert weights (`experts.gate_up_proj`, `experts.down_proj`), infers the
+expert count from the tensor's first dimension instead of reading `config.num_experts`.
+This allows loading models where each layer has a different number of experts.
+
+## Patch
+
+In `Qwen3_5Model.load_weights`, find the fused expert loading block (where
+`is_fused_expert` is True). Replace the hardcoded `num_experts` usage with
+shape-based inference:
+
+```python
+                    if is_fused_expert:
+                        # qwen3.5 no need to transpose
+                        # Use tensor shape for expert count (supports
+                        # variable experts per layer, e.g. REAP pruned)
+                        if "experts.gate_up_proj" in name:
+                            loaded_weight = loaded_weight.chunk(2, dim=-2)
+                            n_exp = loaded_weight[0].shape[0]
+                            success_w1 = self.load_fused_expert_weights(
+                                name_mapped,
+                                params_dict,
+                                loaded_weight[0],
+                                "w1",
+                                n_exp,
+                            )
+                            success_w3 = self.load_fused_expert_weights(
+                                name_mapped,
+                                params_dict,
+                                loaded_weight[1],
+                                "w3",
+                                n_exp,
+                            )
+                            success = success_w1 and success_w3
+                        else:
+                            # down_proj
+                            n_exp = loaded_weight.shape[0]
+                            success = self.load_fused_expert_weights(
+                                name_mapped,
+                                params_dict,
+                                loaded_weight,
+                                shard_id,
+                                n_exp,
+                            )
+```
+
+The key change: `n_exp = loaded_weight[0].shape[0]` (or `loaded_weight.shape[0]` for
+down_proj) replaces the fixed `num_experts` parameter. Each layer's tensor carries its
+own expert count.

patches/qwen3_next.py.patch.md

@@ -0,0 +1,28 @@
+# vLLM Patch: qwen3_next.py — Variable expert count per layer
+
+**File:** `vllm/model_executor/models/qwen3_next.py`
+**Class:** `Qwen3NextSparseMoeBlock.__init__`
+**Tested on:** vLLM 0.16.1rc1.dev188
+
+## What it does
+
+Reads `num_experts_per_layer` (a list) from the model config to support REAP-pruned models
+where each layer has a different number of experts. Falls back to `config.num_experts` for
+standard models.
+
+## Patch
+
+In `Qwen3NextSparseMoeBlock.__init__`, find where `self.n_routed_experts` is set
+(after `self.ep_size = ...`), and replace the fixed assignment with:
+
+```python
+        # Support variable expert counts per layer (REAP pruned models)
+        layer_idx = extract_layer_index(prefix)
+        if hasattr(config, 'num_experts_per_layer') and config.num_experts_per_layer:
+            num_experts = config.num_experts_per_layer[layer_idx]
+        else:
+            num_experts = config.num_experts
+        self.n_routed_experts = num_experts
+```
+
+The `extract_layer_index` function is already imported from `.utils` in the stock file.