[Model] Pass param prefix to LLMHead (#24862)

vllm/model_executor/models/arctic.py

+1

@@ -427,6 +427,7 @@ class ArcticForCausalLM(nn.Module, SupportsPP, SupportsQuant):

427 self.vocab_size,

428 config.hidden_size,

429 quant_config=quant_config,

430 + prefix=maybe_prefix(prefix, "lm_head"),

431 )

432 if self.config.tie_word_embeddings:

433 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/aria.py

+1

@@ -539,6 +539,7 @@ class AriaForConditionalGeneration(nn.Module, SupportsMultiModal):

539 config.text_config.hidden_size,

540 org_num_embeddings=self.language_model.org_vocab_size,

541 quant_config=quant_config,

542 + prefix=maybe_prefix(prefix, "lm_head"),

543 )

544 logit_scale = getattr(config, "logit_scale", 1.0)

545 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

vllm/model_executor/models/baichuan.py

+4 -2

@@ -51,7 +51,8 @@ from vllm.sequence import IntermediateTensors

51

52 from .interfaces import SupportsLoRA, SupportsPP, SupportsQuant

53 from .utils import (AutoWeightsLoader, is_pp_missing_parameter,

54 - make_empty_intermediate_tensors_factory, make_layers)

54 + make_empty_intermediate_tensors_factory, make_layers,

55 + maybe_prefix)

56

57

58 def _get_alibi_slopes(total_num_heads: int) -> torch.Tensor:

@@ -394,7 +395,8 @@ class BaiChuanBaseForCausalLM(nn.Module, SupportsLoRA, SupportsPP,

395 position_embedding=position_embedding)

396 self.lm_head = ParallelLMHead(config.vocab_size,

397 config.hidden_size,

397 - quant_config=quant_config)

398 + quant_config=quant_config,

399 + prefix=maybe_prefix(prefix, "lm_head"))

400 self.lm_head.weight.weight_loader = self.lm_head_weight_loader

401 if self.config.tie_word_embeddings:

402 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/bamba.py

+1

@@ -514,6 +514,7 @@ class BambaForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

514 # We need bigger padding if using lora for kernel

515 # compatibility

516 if not lora_config else lora_config.lora_vocab_padding_size,

517 + prefix=maybe_prefix(prefix, "lm_head"),

518 )

519 # Used to track and store by the Mamba cache between steps.

520 self.mamba_cache: Optional[MambaCacheManager] = None

vllm/model_executor/models/bloom.py

+3 -1

@@ -330,7 +330,9 @@ class BloomForCausalLM(nn.Module, SupportsPP, SupportsQuant):

330 self.lm_head = self.transformer.word_embeddings

331 else:

332 self.lm_head = ParallelLMHead(self.config.vocab_size,

333 - self.config.hidden_size)

333 + self.config.hidden_size,

334 + prefix=maybe_prefix(

335 + prefix, "lm_head"))

336

337 self.logits_processor = LogitsProcessor(config.vocab_size)

338 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/chameleon.py

+1

@@ -960,6 +960,7 @@ class ChameleonForConditionalGeneration(nn.Module, SupportsMultiModal,

960 self.lm_head = ParallelLMHead(

961 self.unpadded_vocab_size,

962 config.hidden_size,

963 + prefix=maybe_prefix(prefix, "lm_head"),

964 )

965 if config.tie_word_embeddings:

966 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/dbrx.py

+1

@@ -438,6 +438,7 @@ class DbrxForCausalLM(nn.Module, SupportsPP):

438 org_num_embeddings=config.vocab_size,

439 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

440 quant_config=quant_config,

441 + prefix=maybe_prefix(prefix, "lm_head"),

442 )

443 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

444 config.vocab_size)

vllm/model_executor/models/deepseek.py

+6 -3

@@ -453,9 +453,12 @@ class DeepseekForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

453 self.quant_config = quant_config

454 self.model = DeepseekModel(vllm_config=vllm_config,

455 prefix=maybe_prefix(prefix, "model"))

456 - self.lm_head = ParallelLMHead(config.vocab_size,

457 - config.hidden_size,

458 - quant_config=quant_config)

456 + self.lm_head = ParallelLMHead(

457 + config.vocab_size,

458 + config.hidden_size,

459 + quant_config=quant_config,

460 + prefix=maybe_prefix(prefix, "lm_head"),

461 + )

462 if self.config.tie_word_embeddings:

463 self.lm_head.weight = self.model.embed_tokens.weight

464 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/deepseek_eagle.py

+2 -1

@@ -199,7 +199,8 @@ class EagleDeepseekV3ForCausalLM(DeepseekV3ForCausalLM):

199

200 self.lm_head = ParallelLMHead(self.config.vocab_size,

201 self.config.hidden_size,

202 - quant_config=quant_config)

202 + quant_config=quant_config,

203 + prefix=maybe_prefix(prefix, "lm_head"))

204

205 logit_scale = getattr(self.config, "logit_scale", 1.0)

206 self.logits_processor = LogitsProcessor(self.config.vocab_size,

vllm/model_executor/models/deepseek_v2.py

+6 -3

@@ -823,9 +823,12 @@ class DeepseekV2ForCausalLM(nn.Module, SupportsPP, MixtureOfExperts,

823 self.model = DeepseekV2Model(vllm_config=vllm_config,

824 prefix=maybe_prefix(prefix, "model"))

825 if get_pp_group().is_last_rank:

826 - self.lm_head = ParallelLMHead(config.vocab_size,

827 - config.hidden_size,

828 - quant_config=quant_config)

826 + self.lm_head = ParallelLMHead(

827 + config.vocab_size,

828 + config.hidden_size,

829 + quant_config=quant_config,

830 + prefix=maybe_prefix(prefix, "lm_head"),

831 + )

832 else:

833 self.lm_head = PPMissingLayer()

834 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/dots1.py

+3 -1

@@ -504,7 +504,9 @@ class Dots1ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

504 if get_pp_group().is_last_rank:

505 self.lm_head = ParallelLMHead(config.vocab_size,

506 config.hidden_size,

507 - quant_config=quant_config)

507 + quant_config=quant_config,

508 + prefix=maybe_prefix(

509 + prefix, "lm_head"))

510 else:

511 self.lm_head = PPMissingLayer()

512 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/ernie45_moe.py

+3 -1

@@ -562,7 +562,9 @@ class Ernie4_5_MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

562 if get_pp_group().is_last_rank:

563 self.lm_head = ParallelLMHead(config.vocab_size,

564 config.hidden_size,

565 - quant_config=quant_config)

565 + quant_config=quant_config,

566 + prefix=maybe_prefix(

567 + prefix, "lm_head"))

568 else:

569 self.lm_head = PPMissingLayer()

570

vllm/model_executor/models/ernie45_vl_moe.py

+3 -1

@@ -557,7 +557,9 @@ class Ernie4_5_VLMoeForCausalLM(nn.Module, SupportsPP):

557 if get_pp_group().is_last_rank:

558 self.lm_head = ParallelLMHead(config.vocab_size,

559 config.hidden_size,

560 - quant_config=quant_config)

560 + quant_config=quant_config,

561 + prefix=maybe_prefix(

562 + prefix, "lm_head"))

563 else:

564 self.lm_head = PPMissingLayer()

565

vllm/model_executor/models/ernie_mtp.py

+2 -1

@@ -158,7 +158,8 @@ class ErnieMTP(nn.Module, SupportsPP):

158 prefix=maybe_prefix(

159 prefix, "model"))

160 self.lm_head = ParallelLMHead(self.config.vocab_size,

161 - self.config.hidden_size)

161 + self.config.hidden_size,

162 + prefix=maybe_prefix(prefix, "lm_head"))

163 self.sampler = get_sampler()

164

165 if self.config.tie_word_embeddings:

vllm/model_executor/models/exaone.py

+1

@@ -502,6 +502,7 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

502 # compatibility

503 if not lora_config else lora_config.lora_vocab_padding_size,

504 quant_config=quant_config,

505 + prefix=maybe_prefix(prefix, "lm_head"),

506 )

507 if config.tie_word_embeddings:

508 self.lm_head.weight = self.transformer.wte.weight

vllm/model_executor/models/exaone4.py

+1

@@ -485,6 +485,7 @@ class Exaone4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

485 # compatibility

486 if not lora_config else lora_config.lora_vocab_padding_size,

487 quant_config=quant_config,

488 + prefix=maybe_prefix(prefix, "lm_head"),

489 )

490 if config.tie_word_embeddings:

491 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/falcon.py

+1

@@ -473,6 +473,7 @@ class FalconForCausalLM(nn.Module, SupportsPP):

473 config.vocab_size,

474 config.hidden_size,

475 quant_config=quant_config,

476 + prefix=maybe_prefix(prefix, "lm_head"),

477 )

478 self.logits_processor = LogitsProcessor(config.vocab_size)

479 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/falcon_h1.py

+1

@@ -607,6 +607,7 @@ class FalconH1ForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

607 # compatibility

608 if not lora_config else

609 lora_config.lora_vocab_padding_size),

610 + prefix=maybe_prefix(prefix, "lm_head"),

611 )

612 self.lm_head_multiplier = config.lm_head_multiplier

613 if self.tie_word_embeddings:

vllm/model_executor/models/glm4_moe.py

+3 -1

@@ -608,7 +608,9 @@ class Glm4MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

608 if get_pp_group().is_last_rank:

609 self.lm_head = ParallelLMHead(config.vocab_size,

610 config.hidden_size,

611 - quant_config=quant_config)

611 + quant_config=quant_config,

612 + prefix=maybe_prefix(

613 + prefix, "lm_head"))

614 else:

615 self.lm_head = PPMissingLayer()

616 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/gpt_bigcode.py

+2 -1

@@ -302,7 +302,8 @@ class GPTBigCodeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

302 self.lm_head = ParallelLMHead(

303 self.transformer.vocab_size,

304 self.transformer.embed_dim,

305 - org_num_embeddings=self.config.vocab_size)

305 + org_num_embeddings=self.config.vocab_size,

306 + prefix=maybe_prefix(prefix, "lm_head"))

307 self.unpadded_vocab_size = config.vocab_size

308 if lora_config:

309 self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

vllm/model_executor/models/gpt_j.py

+1

@@ -306,6 +306,7 @@ class GPTJForCausalLM(nn.Module, SupportsPP):

306 config.n_embd,

307 bias=True,

308 quant_config=quant_config,

309 + prefix=maybe_prefix(prefix, "lm_head"),

310 )

311 self.logits_processor = LogitsProcessor(config.vocab_size)

312 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/gpt_oss.py

+1

@@ -655,6 +655,7 @@ class GptOssForCausalLM(nn.Module, SupportsPP):

655 self.lm_head = ParallelLMHead(

656 self.config.vocab_size,

657 self.config.hidden_size,

658 + prefix=maybe_prefix(prefix, "lm_head"),

659 )

660 self.logits_processor = LogitsProcessor(self.config.vocab_size)

661 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/granite.py

+1

@@ -434,6 +434,7 @@ class GraniteForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

434 # compatibility

435 if not lora_config else lora_config.lora_vocab_padding_size,

436 quant_config=quant_config,

437 + prefix=maybe_prefix(prefix, "lm_head"),

438 )

439 if config.tie_word_embeddings:

440 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/granitemoe.py

+1

@@ -487,6 +487,7 @@ class GraniteMoeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

487 # compatibility

488 if not lora_config else lora_config.lora_vocab_padding_size,

489 quant_config=quant_config,

490 + prefix=maybe_prefix(prefix, "lm_head"),

491 )

492 if config.tie_word_embeddings:

493 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/hunyuan_v1.py

+2 -1

@@ -58,7 +58,7 @@ from vllm.sequence import IntermediateTensors

58

59 from .interfaces import SupportsLoRA, SupportsPP

60 from .utils import (AutoWeightsLoader, PPMissingLayer, is_pp_missing_parameter,

61 - make_layers)

61 + make_layers, maybe_prefix)

62

63

64 def _is_moe(config: PretrainedConfig) -> bool:

@@ -871,6 +871,7 @@ class HunYuanV1Base(nn.Module, SupportsLoRA, SupportsPP):

871 org_num_embeddings=config.vocab_size,

872 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

873 quant_config=quant_config,

874 + prefix=maybe_prefix(prefix, "lm_head"),

875 )

876 if config.tie_word_embeddings:

877 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/idefics3.py

+1

@@ -606,6 +606,7 @@ class Idefics3ForConditionalGeneration(nn.Module, SupportsMultiModal,

606 config.text_config.vocab_size,

607 config.text_config.hidden_size,

608 quant_config=quant_config,

609 + prefix=maybe_prefix(prefix, "lm_head"),

610 )

611 if self.config.text_config.tie_word_embeddings:

612 self.lm_head.weight = self.model.text_model.wte.weight

vllm/model_executor/models/jais.py

+3 -1

@@ -302,7 +302,9 @@ class JAISLMHeadModel(nn.Module, SupportsPP):

302 self.lm_head = self.transformer.wte

303 else:

304 self.lm_head = ParallelLMHead(self.config.vocab_size,

305 - self.config.hidden_size)

305 + self.config.hidden_size,

306 + prefix=maybe_prefix(

307 + prefix, "lm_head"))

308 if hasattr(config, "width_scale"):

309 self.output_logits_scale = config.width_scale

310 else:

vllm/model_executor/models/jamba.py

+1

@@ -502,6 +502,7 @@ class JambaForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

502 # We need bigger padding if using lora for kernel

503 # compatibility

504 if not lora_config else lora_config.lora_vocab_padding_size,

505 + prefix=maybe_prefix(prefix, "lm_head"),

506 )

507 # Used to track and store by the Mamba cache between steps.

508 self.mamba_cache: Optional[MambaCacheManager] = None

vllm/model_executor/models/kimi_vl.py

+1

@@ -328,6 +328,7 @@ class KimiVLForConditionalGeneration(nn.Module, SupportsMultiModal,

328 config.text_config.hidden_size,

329 org_num_embeddings=self.config.text_config.vocab_size,

330 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

331 + prefix=maybe_prefix(prefix, "lm_head"),

332 )

333 else:

334 self.lm_head = PPMissingLayer()

vllm/model_executor/models/llama_eagle3.py

+1 -1

@@ -220,7 +220,7 @@ class Eagle3LlamaForCausalLM(LlamaForCausalLM):

220 self.config.hidden_size,

221 org_num_embeddings=self.config.draft_vocab_size,

222 padding_size=(DEFAULT_VOCAB_PADDING_SIZE),

223 - prefix="")

223 + prefix=maybe_prefix(prefix, "lm_head"))

224 self.logits_processor = LogitsProcessor(self.config.draft_vocab_size,

225 scale=logit_scale)

226 self.draft_id_to_target_id = nn.Parameter(

vllm/model_executor/models/mamba.py

+1

@@ -223,6 +223,7 @@ class MambaForCausalLM(nn.Module, HasInnerState, IsAttentionFree, SupportsPP):

223 # We need bigger padding if using lora for kernel

224 # compatibility

225 if not lora_config else lora_config.lora_vocab_padding_size,

226 + prefix=maybe_prefix(prefix, "lm_head"),

227 )

228

229 # Used to track and store by the Mamba cache between steps.

vllm/model_executor/models/mamba2.py

+1

@@ -278,6 +278,7 @@ class Mamba2ForCausalLM(nn.Module, HasInnerState, IsAttentionFree):

278 # We need bigger padding if using lora for kernel

279 # compatibility

280 if not lora_config else lora_config.lora_vocab_padding_size,

281 + prefix=maybe_prefix(prefix, "lm_head"),

282 )

283 if config.tie_word_embeddings:

284 self.lm_head = self.lm_head.tie_weights(self.backbone.embeddings)

vllm/model_executor/models/medusa.py

+3

@@ -15,6 +15,8 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

15 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

16 from vllm.model_executor.sampling_metadata import SamplingMetadata

17

18 +from .utils import maybe_prefix

19 +

20

21 class ResidualBlock(nn.Module):

22

@@ -71,6 +73,7 @@ class Medusa(nn.Module):

73 config.hidden_size,

74 org_num_embeddings=self.truncated_vocab_size,

75 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

76 + prefix=maybe_prefix(prefix, "lm_head"),

77 )

78 self.lm_heads = [

79 self.lm_head for _ in range(self.config.num_heads)

vllm/model_executor/models/mimo_mtp.py

+2 -1

@@ -158,7 +158,8 @@ class MiMoMTP(nn.Module):

158 prefix=maybe_prefix(

159 prefix, "model"))

160 self.lm_head = ParallelLMHead(self.config.vocab_size,

161 - self.config.hidden_size)

161 + self.config.hidden_size,

162 + prefix=maybe_prefix(prefix, "lm_head"))

163

164 def forward(

165 self,

vllm/model_executor/models/minicpm.py

+1

@@ -547,6 +547,7 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

547 # compatibility

548 if not lora_config else lora_config.lora_vocab_padding_size,

549 quant_config=quant_config,

550 + prefix=maybe_prefix(prefix, "lm_head"),

551 )

552 if config.tie_word_embeddings:

553 self.lm_head = self.lm_head.tie_weights(self.model.embed_tokens)

vllm/model_executor/models/minicpm_eagle.py

+1

@@ -338,6 +338,7 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

338 # compatibility

339 if not lora_config else lora_config.lora_vocab_padding_size,

340 quant_config=quant_config,

341 + prefix=maybe_prefix(prefix, "lm_head"),

342 )

343 if config.tie_word_embeddings:

344 self.lm_head = self.lm_head.tie_weights(self.model.embed_tokens)

vllm/model_executor/models/minimax_text_01.py

+1

@@ -702,6 +702,7 @@ class MiniMaxText01ForCausalLM(nn.Module, HasInnerState, IsHybrid):

702 self.config.hidden_size,

703 org_num_embeddings=self.config.vocab_size,

704 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

705 + prefix=maybe_prefix(prefix, "lm_head"),

706 )

707

708 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

vllm/model_executor/models/mixtral.py

+1

@@ -507,6 +507,7 @@ class MixtralForCausalLM(nn.Module, SupportsLoRA, SupportsPP,

507 # compatibility

508 if not lora_config else lora_config.lora_vocab_padding_size,

509 quant_config=quant_config,

510 + prefix=maybe_prefix(prefix, "lm_head"),

511 )

512 if self.config.tie_word_embeddings:

513 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/molmo.py

+1

@@ -1403,6 +1403,7 @@ class MolmoForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA,

1403 config.embedding_size or config.vocab_size,

1404 config.hidden_size,

1405 quant_config=quant_config,

1406 + prefix=maybe_prefix(prefix, "lm_head"),

1407 )

1408

1409 self.logits_processor = LogitsProcessor(config.embedding_size

vllm/model_executor/models/nemotron.py

+1

@@ -466,6 +466,7 @@ class NemotronForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

466 # compatibility

467 if not lora_config else lora_config.lora_vocab_padding_size,

468 quant_config=quant_config,

469 + prefix=maybe_prefix(prefix, "lm_head"),

470 )

471 if config.tie_word_embeddings:

472 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/nemotron_h.py

+1

@@ -565,6 +565,7 @@ class NemotronHForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

565 # We need bigger padding if using lora for kernel

566 # compatibility

567 if not lora_config else lora_config.lora_vocab_padding_size,

568 + prefix=maybe_prefix(prefix, "lm_head"),

569 )

570 # Used to track and store by the Mamba cache between steps.

571 self.mamba_cache: Optional[MambaCacheManager] = None

vllm/model_executor/models/olmo.py

+1

@@ -364,6 +364,7 @@ class OlmoForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

364 config.hidden_size,

365 org_num_embeddings=config.vocab_size,

366 quant_config=quant_config,

367 + prefix=maybe_prefix(prefix, "lm_head"),

368 )

369 self.logits_processor = LogitsProcessor(config.vocab_size)

370 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/olmoe.py

+2 -1

@@ -450,7 +450,8 @@ class OlmoeForCausalLM(nn.Module, SupportsPP):

450 prefix=maybe_prefix(prefix, "model"))

451 self.lm_head = ParallelLMHead(config.vocab_size,

452 config.hidden_size,

453 - quant_config=quant_config)

453 + quant_config=quant_config,

454 + prefix=maybe_prefix(prefix, "lm_head"))

455 self.logits_processor = LogitsProcessor(config.vocab_size)

456

457 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/opt.py

+3 -1

@@ -375,7 +375,9 @@ class OPTForCausalLM(nn.Module, SupportsPP):

375 self.lm_head = self.model.decoder.embed_tokens

376 else:

377 self.lm_head = ParallelLMHead(config.vocab_size,

378 - config.word_embed_proj_dim)

378 + config.word_embed_proj_dim,

379 + prefix=maybe_prefix(

380 + prefix, "lm_head"))

381 self.logits_processor = LogitsProcessor(config.vocab_size)

382 self.make_empty_intermediate_tensors = (

383 self.model.make_empty_intermediate_tensors)

vllm/model_executor/models/orion.py

+2 -1

@@ -314,7 +314,8 @@ class OrionForCausalLM(nn.Module, SupportsPP):

314 prefix=maybe_prefix(prefix, "model"))

315 self.lm_head = ParallelLMHead(config.vocab_size,

316 config.hidden_size,

317 - quant_config=quant_config)

317 + quant_config=quant_config,

318 + prefix=maybe_prefix(prefix, "lm_head"))

319 if self.config.tie_word_embeddings:

320 self.lm_head.weight = self.model.embed_tokens.weight

321 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/persimmon.py

+2 -1

@@ -307,7 +307,8 @@ class PersimmonForCausalLM(nn.Module, SupportsPP):

307 prefix=maybe_prefix(prefix, "model"))

308 self.lm_head = ParallelLMHead(config.vocab_size,

309 config.hidden_size,

310 - bias=False)

310 + bias=False,

311 + prefix=maybe_prefix(prefix, "lm_head"))

312 self.logits_processor = LogitsProcessor(config.vocab_size)

313 self.make_empty_intermediate_tensors = (

314 self.model.make_empty_intermediate_tensors)

vllm/model_executor/models/phi.py

+2 -1

@@ -322,7 +322,8 @@ class PhiForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

322 self.lm_head = ParallelLMHead(config.vocab_size,

323 config.hidden_size,

324 bias=True,

325 - quant_config=quant_config)

325 + quant_config=quant_config,

326 + prefix=maybe_prefix(prefix, "lm_head"))

327 self.logits_processor = LogitsProcessor(config.vocab_size)

328 self.make_empty_intermediate_tensors = (

329 self.model.make_empty_intermediate_tensors)

vllm/model_executor/models/phi4flash.py

+1

@@ -630,6 +630,7 @@ class Phi4FlashForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsV0Only):

630 # compatibility

631 if not lora_config else lora_config.lora_vocab_padding_size),

632 quant_config=quant_config,

633 + prefix=maybe_prefix(prefix, "lm_head"),

634 )

635 self.embedding_bias = None

636 # Used to track and store by the Mamba cache between steps.

vllm/model_executor/models/phi4mm.py

+1

@@ -989,6 +989,7 @@ class Phi4MMForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

989 org_num_embeddings=config.vocab_size,

990 padding_size=DEFAULT_VOCAB_PADDING_SIZE,

991 quant_config=quant_config,

992 + prefix=maybe_prefix(prefix, "lm_head"),

993 )

994 if config.tie_word_embeddings:

995 self.lm_head = self.lm_head.tie_weights(self.model.embed_tokens)

vllm/model_executor/models/phimoe.py

+1

@@ -645,6 +645,7 @@ class PhiMoEForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

645 if not lora_config else lora_config.lora_vocab_padding_size),

646 quant_config=None,

647 bias=True,

648 + prefix=maybe_prefix(prefix, "lm_head"),

649 )

650 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

651 config.vocab_size)

vllm/model_executor/models/qwen.py

+2 -1

@@ -271,7 +271,8 @@ class QWenBaseModel(nn.Module):

271 prefix, "transformer"))

272 self.lm_head = ParallelLMHead(config.vocab_size,

273 config.hidden_size,

274 - quant_config=quant_config)

274 + quant_config=quant_config,

275 + prefix=maybe_prefix(prefix, "lm_head"))

276 if self.config.tie_word_embeddings:

277 self.lm_head.weight = self.transformer.wte.weight

278 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/qwen2_moe.py

+2 -1

@@ -519,7 +519,8 @@ class Qwen2MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

519 prefix=maybe_prefix(prefix, "model"))

520 self.lm_head = ParallelLMHead(config.vocab_size,

521 config.hidden_size,

522 - quant_config=quant_config)

522 + quant_config=quant_config,

523 + prefix=maybe_prefix(prefix, "lm_head"))

524 if self.config.tie_word_embeddings:

525 self.lm_head.weight = self.model.embed_tokens.weight

526 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/qwen3_moe.py

+2 -1

@@ -605,7 +605,8 @@ class Qwen3MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA,

605 prefix=maybe_prefix(prefix, "model"))

606 self.lm_head = ParallelLMHead(config.vocab_size,

607 config.hidden_size,

608 - quant_config=quant_config)

608 + quant_config=quant_config,

609 + prefix=maybe_prefix(prefix, "lm_head"))

610 if self.config.tie_word_embeddings:

611 self.lm_head.weight = self.model.embed_tokens.weight

612 self.logits_processor = LogitsProcessor(config.vocab_size)

vllm/model_executor/models/qwen3_next.py

+1 -1

@@ -1089,7 +1089,7 @@ class Qwen3NextForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

1089 # We need bigger padding if using lora for kernel

1090 # compatibility

1091 if not lora_config else lora_config.lora_vocab_padding_size,

1092 - )

1092 + prefix=maybe_prefix(prefix, "lm_head"))

1093 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

1094 config.vocab_size)

1095 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/qwen3_next_mtp.py

+2 -1

@@ -238,7 +238,8 @@ class Qwen3NextMTP(nn.Module, SupportsPP):

238 self.lm_head = ParallelLMHead(self.unpadded_vocab_size,

239 config.hidden_size,

240 org_num_embeddings=config.vocab_size,

241 - padding_size=DEFAULT_VOCAB_PADDING_SIZE)

241 + padding_size=DEFAULT_VOCAB_PADDING_SIZE,

242 + prefix=maybe_prefix(prefix, "lm_head"))

243 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

244 config.vocab_size)

245 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/solar.py

+1

@@ -469,6 +469,7 @@ class SolarForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

469 # compatibility

470 if not lora_config else lora_config.lora_vocab_padding_size,

471 quant_config=quant_config,

472 + prefix=maybe_prefix(prefix, "lm_head"),

473 )

474 if config.tie_word_embeddings:

475 self.lm_head.weight = self.model.embed_tokens.weight

vllm/model_executor/models/step3_text.py

+3 -1

@@ -35,7 +35,8 @@ from vllm.sequence import IntermediateTensors

35

36 from .interfaces import SupportsPP

37 from .utils import (PPMissingLayer, is_pp_missing_parameter,

38 - make_empty_intermediate_tensors_factory, make_layers)

38 + make_empty_intermediate_tensors_factory, make_layers,

39 + maybe_prefix)

40

41 logger = init_logger(__name__)

42

@@ -386,6 +387,7 @@ class Step3TextForCausalLM(nn.Module, SupportsPP):

387 org_num_embeddings=config.vocab_size,

388 padding_size=DEFAULT_VOCAB_PADDING_SIZE

389 if not lora_config else lora_config.lora_vocab_padding_size,

390 + prefix=maybe_prefix(prefix, "lm_head"),

391 )

392 self.logits_processor = LogitsProcessor(self.unpadded_vocab_size,

393 config.vocab_size)

vllm/model_executor/models/zamba2.py

+1

@@ -941,6 +941,7 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid):

941 # We need bigger padding if using lora for kernel

942 # compatibility

943 if not lora_config else lora_config.lora_vocab_padding_size,

944 + prefix=maybe_prefix(prefix, "lm_head"),

945 )

946 # Tie weights with input embeddings if using same dimensions

947 self.lm_head = self.lm_head.tie_weights(self.model.embed_tokens)