9d1c474704 · tduncan/Nvidia-Optimization-Stack-VLLM

vllm/model_executor/models/apertus.py

+5 -25

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

49 from vllm.model_executor.layers.quantization import QuantizationConfig

50 from vllm.model_executor.layers.rotary_embedding import get_rope

51 from vllm.model_executor.layers.vocab_parallel_embedding import (

52 - DEFAULT_VOCAB_PADDING_SIZE,

52 ParallelLMHead,

53 VocabParallelEmbedding,

54 )

@@ -346,24 +345,18 @@ class ApertusModel(nn.Module):

345 config = vllm_config.model_config.hf_config

346 cache_config = vllm_config.cache_config

347 quant_config = vllm_config.quant_config

349 - lora_config = vllm_config.lora_config

348

349 self.config = config

350 self.quant_config = quant_config

353 - lora_vocab = (

354 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

355 - if lora_config

356 - else 0

357 - )

358 - self.vocab_size = config.vocab_size + lora_vocab

359 - self.org_vocab_size = config.vocab_size

351 +

352 + self.vocab_size = config.vocab_size

353 +

354 if get_pp_group().is_first_rank or (

355 config.tie_word_embeddings and get_pp_group().is_last_rank

356 ):

357 self.embed_tokens = VocabParallelEmbedding(

358 self.vocab_size,

359 config.hidden_size,

366 - org_num_embeddings=config.vocab_size,

360 quant_config=quant_config,

361 )

362 else:

@@ -518,9 +511,7 @@ class ApertusForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

511 super().__init__()

512 config = vllm_config.model_config.hf_config

513 quant_config = vllm_config.quant_config

521 - lora_config = vllm_config.lora_config

514 self.config = config

523 - self.lora_config = lora_config

515

516 self.model = self._init_model(

517 vllm_config=vllm_config,

@@ -529,20 +520,9 @@ class ApertusForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

520 )

521

522 if get_pp_group().is_last_rank:

532 - self.unpadded_vocab_size = config.vocab_size

533 - if lora_config:

534 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

523 self.lm_head = ParallelLMHead(

536 - self.unpadded_vocab_size,

524 + config.vocab_size,

525 config.hidden_size,

538 - org_num_embeddings=config.vocab_size,

539 - padding_size=(

540 - DEFAULT_VOCAB_PADDING_SIZE

541 - # We need bigger padding if using lora for kernel

542 - # compatibility

543 - if not lora_config

544 - else lora_config.lora_vocab_padding_size

545 - ),

526 quant_config=quant_config,

527 prefix=maybe_prefix(prefix, "lm_head"),

528 )

@@ -551,7 +531,7 @@ class ApertusForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

531

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

533 self.logits_processor = LogitsProcessor(

554 - self.unpadded_vocab_size, config.vocab_size, logit_scale

534 + config.vocab_size, scale=logit_scale

535 )

536 else:

537 self.lm_head = PPMissingLayer()

vllm/model_executor/models/arcee.py

+2 -8

@@ -23,7 +23,6 @@ from vllm.model_executor.layers.layernorm import RMSNorm

23 from vllm.model_executor.layers.linear import ColumnParallelLinear, RowParallelLinear

24 from vllm.model_executor.layers.logits_processor import LogitsProcessor

25 from vllm.model_executor.layers.vocab_parallel_embedding import (

26 - DEFAULT_VOCAB_PADDING_SIZE,

26 ParallelLMHead,

27 VocabParallelEmbedding,

28 )

@@ -200,7 +199,6 @@ class ArceeModel(nn.Module):

199 self.quant_config = quant_config

200 self.config = config

201 self.vocab_size = config.vocab_size

203 - self.org_vocab_size = config.vocab_size

202

203 # Word embeddings (parallelized if using pipeline parallel)

204 if get_pp_group().is_first_rank or (

@@ -209,7 +207,6 @@ class ArceeModel(nn.Module):

207 self.embed_tokens = VocabParallelEmbedding(

208 self.vocab_size,

209 config.hidden_size,

212 - org_num_embeddings=config.vocab_size,

210 quant_config=quant_config,

211 )

212 else:

@@ -383,13 +380,10 @@ class ArceeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

380 if get_pp_group().is_last_rank:

381 # Determine vocabulary size (including any LoRA extra tokens

382 # for padded LM head)

386 - self.unpadded_vocab_size = config.vocab_size

383

384 self.lm_head = ParallelLMHead(

389 - self.unpadded_vocab_size,

385 + config.vocab_size,

386 config.hidden_size,

391 - org_num_embeddings=config.vocab_size,

392 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

387 quant_config=vllm_config.quant_config,

388 bias=getattr(config, "lm_head_bias", False),

389 prefix=f"{prefix}.lm_head",

@@ -399,7 +393,7 @@ class ArceeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

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

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

395 self.logits_processor = LogitsProcessor(

402 - self.unpadded_vocab_size, config.vocab_size, logit_scale

396 + config.vocab_size, scale=logit_scale

397 )

398 else:

399 # Placeholder for lm_head on non-last ranks

vllm/model_executor/models/arctic.py

+2 -4

@@ -490,10 +490,8 @@ class ArcticForCausalLM(nn.Module, SupportsPP, SupportsQuant):

490 self.lm_head.weight = self.model.embed_tokens.weight

491 self.num_experts = config.num_local_experts

492 self.num_experts_per_tok = config.num_experts_per_tok

493 - self.unpadded_vocab_size = config.vocab_size

494 - self.logits_processor = LogitsProcessor(

495 - self.unpadded_vocab_size, config.vocab_size

496 - )

493 +

494 + self.logits_processor = LogitsProcessor(config.vocab_size)

495 self.make_empty_intermediate_tensors = (

496 self.model.make_empty_intermediate_tensors

497 )

vllm/model_executor/models/aria.py

+2 -6

@@ -547,18 +547,14 @@ class AriaForConditionalGeneration(nn.Module, SupportsMultiModal):

547 self.pad_token_id = (

548 self.config.pad_token_id if self.config.pad_token_id is not None else -1

549 )

550 - self.unpadded_vocab_size = config.text_config.vocab_size

550 self.lm_head = ParallelLMHead(

552 - self.unpadded_vocab_size,

551 + self.vocab_size,

552 config.text_config.hidden_size,

554 - org_num_embeddings=self.language_model.org_vocab_size,

553 quant_config=quant_config,

554 prefix=maybe_prefix(prefix, "lm_head"),

555 )

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

559 - self.logits_processor = LogitsProcessor(

560 - self.unpadded_vocab_size, self.vocab_size, logit_scale

561 - )

557 + self.logits_processor = LogitsProcessor(self.vocab_size, scale=logit_scale)

558

559 def _parse_and_validate_image_input(

560 self, **kwargs: object

vllm/model_executor/models/baichuan.py

+2 -2

@@ -402,9 +402,9 @@ class BaiChuanBaseForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsQuant

402 super().__init__()

403 config = vllm_config.model_config.hf_config

404 quant_config = vllm_config.quant_config

405 - lora_config = vllm_config.lora_config

405 +

406 self.config = config

407 - self.lora_config = lora_config

407 +

408 self.tp_size = get_tensor_model_parallel_world_size()

409 self.quant_config = quant_config

410 self.model = BaiChuanModel(

vllm/model_executor/models/bailing_moe.py

-2

@@ -581,10 +581,8 @@ class BailingMoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

581 config = vllm_config.model_config.hf_config.get_text_config()

582 vllm_config.model_config.hf_config = config

583 quant_config = vllm_config.quant_config

584 - lora_config = vllm_config.lora_config

584

585 self.config = config

587 - self.lora_config = lora_config

586 self.quant_config = quant_config

587 self.max_position_embeddings = config.max_position_embeddings

588 self.model = BailingMoeModel(

vllm/model_executor/models/bamba.py

+6 -24

@@ -30,7 +30,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

30 from vllm.model_executor.layers.quantization import QuantizationConfig

31 from vllm.model_executor.layers.rotary_embedding import get_rope

32 from vllm.model_executor.layers.vocab_parallel_embedding import (

33 - DEFAULT_VOCAB_PADDING_SIZE,

33 ParallelLMHead,

34 VocabParallelEmbedding,

35 )

@@ -284,21 +283,14 @@ class BambaModel(nn.Module):

283 model_config = vllm_config.model_config

284 cache_config = vllm_config.cache_config

285 quant_config = vllm_config.quant_config

287 - lora_config = vllm_config.lora_config

286

287 self.config = config

290 - lora_vocab = (

291 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

292 - if lora_config

293 - else 0

294 - )

295 - self.vocab_size = config.vocab_size + lora_vocab

296 - self.org_vocab_size = config.vocab_size

288 +

289 + self.vocab_size = config.vocab_size

290

291 self.embed_tokens = VocabParallelEmbedding(

292 self.vocab_size,

293 config.hidden_size,

301 - org_num_embeddings=config.vocab_size,

294 )

295

296 def get_layer(prefix: str):

@@ -478,7 +470,7 @@ class BambaForCausalLM(

470 config = vllm_config.model_config.hf_config

471 self.vllm_config = vllm_config

472 self.model_config = vllm_config.model_config

481 - lora_config = vllm_config.lora_config

473 +

474 scheduler_config = vllm_config.scheduler_config

475 self.quant_config = vllm_config.quant_config

476

@@ -488,24 +480,14 @@ class BambaForCausalLM(

480 self.model = BambaModel(

481 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

482 )

491 - self.unpadded_vocab_size = config.vocab_size

492 - if lora_config:

493 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

483 +

484 self.lm_head = ParallelLMHead(

495 - self.unpadded_vocab_size,

485 + config.vocab_size,

486 config.hidden_size,

497 - org_num_embeddings=config.vocab_size,

498 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

499 - # We need bigger padding if using lora for kernel

500 - # compatibility

501 - if not lora_config

502 - else lora_config.lora_vocab_padding_size,

487 prefix=maybe_prefix(prefix, "lm_head"),

488 )

489

506 - self.logits_processor = LogitsProcessor(

507 - self.unpadded_vocab_size, config.vocab_size

508 - )

490 + self.logits_processor = LogitsProcessor(config.vocab_size)

491

492 self.make_empty_intermediate_tensors = (

493 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/chameleon.py

+3 -5

@@ -963,9 +963,9 @@ class ChameleonForConditionalGeneration(

963 self.model = ChameleonModel(

964 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

965 )

966 - self.unpadded_vocab_size = config.vocab_size

966 +

967 self.lm_head = ParallelLMHead(

968 - self.unpadded_vocab_size,

968 + config.vocab_size,

969 config.hidden_size,

970 prefix=maybe_prefix(prefix, "lm_head"),

971 )

@@ -973,9 +973,7 @@ class ChameleonForConditionalGeneration(

973 self.lm_head.weight = self.model.embed_tokens.weight

974

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

976 - self.logits_processor = LogitsProcessor(

977 - self.unpadded_vocab_size, config.vocab_size, logit_scale

978 - )

976 + self.logits_processor = LogitsProcessor(config.vocab_size, scale=logit_scale)

977 self.make_empty_intermediate_tensors = (

978 self.model.make_empty_intermediate_tensors

979 )

vllm/model_executor/models/chatglm.py

+1 -2

@@ -433,10 +433,9 @@ class ChatGLMBaseModel(nn.Module):

433 super().__init__()

434 config = vllm_config.model_config.hf_config

435 quant_config = vllm_config.quant_config

436 - lora_config = vllm_config.lora_config

436 +

437 multimodal_config = vllm_config.model_config.multimodal_config

438 self.config = config

439 - self.lora_config = lora_config

439 self.multimodal_config = multimodal_config

440

441 self.quant_config = quant_config

vllm/model_executor/models/commandr.py

+6 -13

@@ -288,17 +288,12 @@ class CohereModel(nn.Module):

288 config = vllm_config.model_config.hf_config

289 cache_config = vllm_config.cache_config

290 quant_config = vllm_config.quant_config

291 - lora_config = vllm_config.lora_config

291 self.quant_config = quant_config

292

293 self.config = config

295 - lora_vocab = (

296 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

297 - if lora_config

298 - else 0

299 - )

300 - self.vocab_size = config.vocab_size + lora_vocab

301 - self.org_vocab_size = config.vocab_size

294 +

295 + self.vocab_size = config.vocab_size

296 +

297 self.embed_tokens = VocabParallelEmbedding(

298 config.vocab_size, config.hidden_size

299 )

@@ -424,17 +419,15 @@ class CohereForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsQuant):

419 super().__init__()

420 config = vllm_config.model_config.hf_config

421 quant_config = vllm_config.quant_config

427 - lora_config = vllm_config.lora_config

422 +

423 self.config = config

424 # currently all existing command R models have `tie_word_embeddings`

425 # enabled

426 assert config.tie_word_embeddings

432 - self.unpadded_vocab_size = config.vocab_size

433 - if lora_config:

434 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

427 +

428 self.quant_config = quant_config

429 self.logits_processor = LogitsProcessor(

437 - self.unpadded_vocab_size, config.vocab_size, scale=config.logit_scale

430 + config.vocab_size, scale=config.logit_scale

431 )

432 self.model = CohereModel(

433 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

vllm/model_executor/models/dbrx.py

+2 -7

@@ -25,7 +25,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

25 from vllm.model_executor.layers.quantization import QuantizationConfig

26 from vllm.model_executor.layers.rotary_embedding import get_rope

27 from vllm.model_executor.layers.vocab_parallel_embedding import (

28 - DEFAULT_VOCAB_PADDING_SIZE,

28 ParallelLMHead,

29 VocabParallelEmbedding,

30 )

@@ -441,21 +440,17 @@ class DbrxForCausalLM(nn.Module, SupportsPP):

440 if config.tie_word_embeddings:

441 raise ValueError("tie_word_embeddings is not supported for Dbrx models.")

442 self.quant_config = quant_config

444 - self.unpadded_vocab_size = config.vocab_size

443 +

444 self.transformer = DbrxModel(

445 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "transformer")

446 )

447 self.lm_head = ParallelLMHead(

448 config.vocab_size,

449 config.d_model,

451 - org_num_embeddings=config.vocab_size,

452 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

450 quant_config=quant_config,

451 prefix=maybe_prefix(prefix, "lm_head"),

452 )

456 - self.logits_processor = LogitsProcessor(

457 - self.unpadded_vocab_size, config.vocab_size

458 - )

453 + self.logits_processor = LogitsProcessor(config.vocab_size)

454 self.make_empty_intermediate_tensors = (

455 self.transformer.make_empty_intermediate_tensors

456 )

vllm/model_executor/models/exaone.py

+5 -22

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

48 from vllm.model_executor.layers.quantization import QuantizationConfig

49 from vllm.model_executor.layers.rotary_embedding import get_rope

50 from vllm.model_executor.layers.vocab_parallel_embedding import (

51 - DEFAULT_VOCAB_PADDING_SIZE,

51 ParallelLMHead,

52 VocabParallelEmbedding,

53 )

@@ -323,16 +322,11 @@ class ExaoneModel(nn.Module):

322 config = vllm_config.model_config.hf_config

323 cache_config = vllm_config.cache_config

324 quant_config = vllm_config.quant_config

326 - lora_config = vllm_config.lora_config

325

326 self.config = config

327 self.quant_config = quant_config

330 - lora_vocab = (

331 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

332 - if lora_config

333 - else 0

334 - )

335 - self.vocab_size = config.vocab_size + lora_vocab

328 +

329 + self.vocab_size = config.vocab_size

330 self.wte = config.vocab_size

331 if get_pp_group().is_first_rank or (

332 config.tie_word_embeddings and get_pp_group().is_last_rank

@@ -340,7 +334,6 @@ class ExaoneModel(nn.Module):

334 self.wte = VocabParallelEmbedding(

335 self.vocab_size,

336 config.hidden_size,

343 - org_num_embeddings=config.vocab_size,

337 quant_config=quant_config,

338 )

339 else:

@@ -489,10 +482,9 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

482 super().__init__()

483 config = vllm_config.model_config.hf_config

484 quant_config = vllm_config.quant_config

492 - lora_config = vllm_config.lora_config

485

486 self.config = config

495 - self.lora_config = lora_config

487 +

488 self.quant_config = quant_config

489

490 self.transformer = ExaoneModel(

@@ -500,18 +492,9 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

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

493 )

494 if get_pp_group().is_last_rank:

503 - self.unpadded_vocab_size = config.vocab_size

504 - if lora_config:

505 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

495 self.lm_head = ParallelLMHead(

507 - self.unpadded_vocab_size,

496 + config.vocab_size,

497 config.hidden_size,

509 - org_num_embeddings=config.vocab_size,

510 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

511 - # We need bigger padding if using lora for kernel

512 - # compatibility

513 - if not lora_config

514 - else lora_config.lora_vocab_padding_size,

498 quant_config=quant_config,

499 prefix=maybe_prefix(prefix, "lm_head"),

500 )

@@ -520,7 +503,7 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

503

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

505 self.logits_processor = LogitsProcessor(

523 - self.unpadded_vocab_size, config.vocab_size, logit_scale

506 + config.vocab_size, scale=logit_scale

507 )

508 else:

509 self.lm_head = PPMissingLayer()

vllm/model_executor/models/exaone4.py

+4 -22

@@ -44,7 +44,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

44 from vllm.model_executor.layers.quantization import QuantizationConfig

45 from vllm.model_executor.layers.rotary_embedding import get_rope

46 from vllm.model_executor.layers.vocab_parallel_embedding import (

47 - DEFAULT_VOCAB_PADDING_SIZE,

47 ParallelLMHead,

48 VocabParallelEmbedding,

49 )

@@ -311,23 +310,17 @@ class Exaone4Model(nn.Module):

310 config = vllm_config.model_config.hf_config

311 cache_config = vllm_config.cache_config

312 quant_config = vllm_config.quant_config

314 - lora_config = vllm_config.lora_config

313

314 self.config = config

315 self.quant_config = quant_config

318 - lora_vocab = (

319 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

320 - if lora_config

321 - else 0

322 - )

323 - self.vocab_size = config.vocab_size + lora_vocab

316 +

317 + self.vocab_size = config.vocab_size

318 if get_pp_group().is_first_rank or (

319 config.tie_word_embeddings and get_pp_group().is_last_rank

320 ):

321 self.embed_tokens = VocabParallelEmbedding(

322 self.vocab_size,

323 config.hidden_size,

330 - org_num_embeddings=config.vocab_size,

324 quant_config=quant_config,

325 )

326 else:

@@ -476,10 +469,8 @@ class Exaone4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

469 super().__init__()

470 config = vllm_config.model_config.hf_config

471 quant_config = vllm_config.quant_config

479 - lora_config = vllm_config.lora_config

472

473 self.config = config

482 - self.lora_config = lora_config

474 self.quant_config = quant_config

475

476 self.model = Exaone4Model(

@@ -487,18 +478,9 @@ class Exaone4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

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

479 )

480 if get_pp_group().is_last_rank:

490 - self.unpadded_vocab_size = config.vocab_size

491 - if lora_config:

492 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

481 self.lm_head = ParallelLMHead(

494 - self.unpadded_vocab_size,

482 + config.vocab_size,

483 config.hidden_size,

496 - org_num_embeddings=config.vocab_size,

497 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

498 - # We need bigger padding if using lora for kernel

499 - # compatibility

500 - if not lora_config

501 - else lora_config.lora_vocab_padding_size,

484 quant_config=quant_config,

485 prefix=maybe_prefix(prefix, "lm_head"),

486 )

@@ -507,7 +489,7 @@ class Exaone4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

489

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

491 self.logits_processor = LogitsProcessor(

510 - self.unpadded_vocab_size, config.vocab_size, logit_scale

492 + config.vocab_size, scale=logit_scale

493 )

494 else:

495 self.lm_head = PPMissingLayer()

vllm/model_executor/models/falcon_h1.py

+7 -24

@@ -30,7 +30,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

30 from vllm.model_executor.layers.quantization import QuantizationConfig

31 from vllm.model_executor.layers.rotary_embedding import get_rope

32 from vllm.model_executor.layers.vocab_parallel_embedding import (

33 - DEFAULT_VOCAB_PADDING_SIZE,

33 ParallelLMHead,

34 VocabParallelEmbedding,

35 )

@@ -424,21 +423,15 @@ class FalconH1Model(nn.Module):

423 model_config = vllm_config.model_config

424 cache_config = vllm_config.cache_config

425 quant_config = vllm_config.quant_config

427 - lora_config = vllm_config.lora_config

426

427 self.config = config

430 - lora_vocab = (

431 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

432 - if lora_config

433 - else 0

434 - )

435 - self.vocab_size = config.vocab_size + lora_vocab

436 - self.org_vocab_size = config.vocab_size

428 +

429 + self.vocab_size = config.vocab_size

430 +

431 if get_pp_group().is_first_rank:

432 self.embed_tokens = VocabParallelEmbedding(

433 self.vocab_size,

434 config.hidden_size,

441 - org_num_embeddings=config.vocab_size,

435 )

436 self.embedding_multiplier = config.embedding_multiplier

437 else:

@@ -572,7 +565,7 @@ class FalconH1ForCausalLM(

565 config = vllm_config.model_config.hf_config

566 self.vllm_config = vllm_config

567 self.model_config = vllm_config.model_config

575 - lora_config = vllm_config.lora_config

568 +

569 scheduler_config = vllm_config.scheduler_config

570

571 self.quant_config = vllm_config.quant_config

@@ -584,21 +577,11 @@ class FalconH1ForCausalLM(

577 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

578 )

579 self.tie_word_embeddings = config.tie_word_embeddings

587 - self.unpadded_vocab_size = config.vocab_size

588 - if lora_config:

589 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

580 +

581 if get_pp_group().is_last_rank:

582 self.lm_head = ParallelLMHead(

592 - self.unpadded_vocab_size,

583 + config.vocab_size,

584 config.hidden_size,

594 - org_num_embeddings=config.vocab_size,

595 - padding_size=(

596 - DEFAULT_VOCAB_PADDING_SIZE

597 - # We need bigger padding if using lora for kernel

598 - # compatibility

599 - if not lora_config

600 - else lora_config.lora_vocab_padding_size

601 - ),

585 prefix=maybe_prefix(prefix, "lm_head"),

586 )

587 self.lm_head_multiplier = config.lm_head_multiplier

@@ -607,7 +590,7 @@ class FalconH1ForCausalLM(

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

591

592 self.logits_processor = LogitsProcessor(

610 - self.unpadded_vocab_size,

593 + config.vocab_size,

594 config.vocab_size,

595 scale=config.lm_head_multiplier,

596 )

vllm/model_executor/models/gemma.py

-2

@@ -382,12 +382,10 @@ class GemmaForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

382 super().__init__()

383 config = vllm_config.model_config.hf_config

384 quant_config = vllm_config.quant_config

385 - lora_config = vllm_config.lora_config

385

386 self.config = config

387 # currently all existing Gemma models have `tie_word_embeddings` enabled

388 assert config.tie_word_embeddings

390 - self.lora_config = lora_config

389

390 self.quant_config = quant_config

391 self.model = GemmaModel(

vllm/model_executor/models/gemma2.py

+1 -2

@@ -393,8 +393,7 @@ class Gemma2ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

393 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

394 config = vllm_config.model_config.hf_config

395 quant_config = vllm_config.quant_config

396 - lora_config = vllm_config.lora_config

397 - del lora_config # Unused.

396 +

397 super().__init__()

398 self.config = config

399 # currently all existing Gemma models have `tie_word_embeddings` enabled

vllm/model_executor/models/gemma3.py

+1 -2

@@ -524,8 +524,7 @@ class Gemma3ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

524 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

525 config = vllm_config.model_config.hf_config

526 quant_config = vllm_config.quant_config

527 - lora_config = vllm_config.lora_config

528 - del lora_config # Unused.

527 +

528 super().__init__()

529 self.config = config

530 # currently all existing Gemma models have `tie_word_embeddings` enabled

vllm/model_executor/models/gemma3n.py

+1 -2

@@ -1114,8 +1114,7 @@ class Gemma3nForCausalLM(nn.Module):

1114

1115 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

1116 config = vllm_config.model_config.hf_config

1117 - lora_config = vllm_config.lora_config

1118 - del lora_config # Unused.

1117 +

1118 super().__init__()

1119 self.config = config

1120 self.cache_config = vllm_config.cache_config

vllm/model_executor/models/glm4.py

-2

@@ -248,10 +248,8 @@ class Glm4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

248 super().__init__()

249 config = vllm_config.model_config.hf_config

250 quant_config = vllm_config.quant_config

251 - lora_config = vllm_config.lora_config

251

252 self.config = config

254 - self.lora_config = lora_config

253

254 self.quant_config = quant_config

255 self.model = Glm4Model(

vllm/model_executor/models/gpt_bigcode.py

+4 -16

@@ -207,18 +207,13 @@ class GPTBigCodeModel(nn.Module):

207 config = vllm_config.model_config.hf_config

208 cache_config = vllm_config.cache_config

209 quant_config = vllm_config.quant_config

210 - lora_config = vllm_config.lora_config

210

211 self.config = config

212 assert not config.add_cross_attention

213

214 self.embed_dim = config.hidden_size

216 - lora_vocab = (

217 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

218 - if lora_config

219 - else 0

220 - )

221 - self.vocab_size = config.vocab_size + lora_vocab

215 +

216 + self.vocab_size = config.vocab_size

217 self.wte = VocabParallelEmbedding(

218 self.vocab_size, self.embed_dim, org_num_embeddings=config.vocab_size

219 )

@@ -290,10 +285,8 @@ class GPTBigCodeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

285 super().__init__()

286 config = vllm_config.model_config.hf_config

287 quant_config = vllm_config.quant_config

293 - lora_config = vllm_config.lora_config

288

289 self.config = config

296 - self.lora_config = lora_config

290

291 self.quant_config = quant_config

292 self.transformer = GPTBigCodeModel(

@@ -305,15 +298,10 @@ class GPTBigCodeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

298 self.lm_head = ParallelLMHead(

299 self.transformer.vocab_size,

300 self.transformer.embed_dim,

308 - org_num_embeddings=self.config.vocab_size,

301 prefix=maybe_prefix(prefix, "lm_head"),

302 )

311 - self.unpadded_vocab_size = config.vocab_size

312 - if lora_config:

313 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

314 - self.logits_processor = LogitsProcessor(

315 - self.unpadded_vocab_size, config.vocab_size

316 - )

303 +

304 + self.logits_processor = LogitsProcessor(config.vocab_size)

305 self.make_empty_intermediate_tensors = (

306 self.transformer.make_empty_intermediate_tensors

307 )

vllm/model_executor/models/granitemoe.py

+4 -23

@@ -50,7 +50,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

50 from vllm.model_executor.layers.quantization import QuantizationConfig

51 from vllm.model_executor.layers.rotary_embedding import get_rope

52 from vllm.model_executor.layers.vocab_parallel_embedding import (

53 - DEFAULT_VOCAB_PADDING_SIZE,

53 ParallelLMHead,

54 VocabParallelEmbedding,

55 )

@@ -296,22 +295,15 @@ class GraniteMoeModel(nn.Module):

295

296 config = vllm_config.model_config.hf_config

297 quant_config = vllm_config.quant_config

299 - lora_config = vllm_config.lora_config

298

299 self.config = config

300 self.quant_config = quant_config # Required by MixtralModel

303 - lora_vocab = (

304 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

305 - if lora_config

306 - else 0

307 - )

308 - self.vocab_size = config.vocab_size + lora_vocab

309 - self.org_vocab_size = config.vocab_size

301 +

302 + self.vocab_size = config.vocab_size

303

304 self.embed_tokens = VocabParallelEmbedding(

305 self.vocab_size,

306 config.hidden_size,

314 - org_num_embeddings=config.vocab_size,

307 )

308 self.embedding_multiplier = config.embedding_multiplier

309

@@ -518,26 +510,16 @@ class GraniteMoeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

510 super().__init__()

511 config = vllm_config.model_config.hf_config

512 quant_config = vllm_config.quant_config

521 - lora_config = vllm_config.lora_config

513

514 self.config = config

524 - self.lora_config = lora_config

515

516 self.model = GraniteMoeModel(

517 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

518 )

529 - self.unpadded_vocab_size = config.vocab_size

530 - if lora_config:

531 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

519 +

520 self.lm_head = ParallelLMHead(

533 - self.unpadded_vocab_size,

521 + config.vocab_size,

522 config.hidden_size,

535 - org_num_embeddings=config.vocab_size,

536 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

537 - # We need bigger padding if using lora for kernel

538 - # compatibility

539 - if not lora_config

540 - else lora_config.lora_vocab_padding_size,

523 quant_config=quant_config,

524 prefix=maybe_prefix(prefix, "lm_head"),

525 )

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

527 self.lm_head.weight = self.model.embed_tokens.weight

528

529 self.logits_processor = LogitsProcessor(

548 - self.unpadded_vocab_size,

530 config.vocab_size,

531 scale=1 / self.config.logits_scaling,

532 )

vllm/model_executor/models/granitemoehybrid.py

+5 -22

@@ -25,7 +25,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

25 from vllm.model_executor.layers.quantization import QuantizationConfig

26 from vllm.model_executor.layers.rotary_embedding import get_rope

27 from vllm.model_executor.layers.vocab_parallel_embedding import (

28 - DEFAULT_VOCAB_PADDING_SIZE,

28 ParallelLMHead,

29 VocabParallelEmbedding,

30 )

@@ -334,22 +333,15 @@ class GraniteMoeHybridModel(nn.Module):

333 model_config = vllm_config.model_config

334 cache_config = vllm_config.cache_config

335 quant_config = vllm_config.quant_config

337 - lora_config = vllm_config.lora_config

336

337 self.config = config

338 self.quant_config = quant_config

341 - lora_vocab = (

342 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

343 - if lora_config

344 - else 0

345 - )

346 - self.vocab_size = config.vocab_size + lora_vocab

347 - self.org_vocab_size = config.vocab_size

339 +

340 + self.vocab_size = config.vocab_size

341

342 self.embed_tokens = VocabParallelEmbedding(

343 self.vocab_size,

344 config.hidden_size,

352 - org_num_embeddings=config.vocab_size,

345 )

346 self.embedding_multiplier = config.embedding_multiplier

347

@@ -658,7 +650,7 @@ class GraniteMoeHybridForCausalLM(

650 config = vllm_config.model_config.hf_config

651 self.vllm_config = vllm_config

652 self.model_config = vllm_config.model_config

661 - lora_config = vllm_config.lora_config

653 +

654 scheduler_config = vllm_config.scheduler_config

655 self.quant_config = vllm_config.quant_config

656 self.config = config

@@ -666,26 +658,17 @@ class GraniteMoeHybridForCausalLM(

658 self.model = GraniteMoeHybridModel(

659 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

660 )

669 - self.unpadded_vocab_size = config.vocab_size

670 - if lora_config:

671 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

661

662 self.lm_head = ParallelLMHead(

674 - self.unpadded_vocab_size,

663 + config.vocab_size,

664 config.hidden_size,

676 - org_num_embeddings=config.vocab_size,

677 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

678 - # We need bigger padding if using lora for kernel

679 - # compatibility

680 - if not lora_config

681 - else lora_config.lora_vocab_padding_size,

665 quant_config=self.quant_config,

666 prefix=maybe_prefix(prefix, "lm_head"),

667 )

668 if config.tie_word_embeddings:

669 self.lm_head.weight = self.model.embed_tokens.weight

670 self.logits_processor = LogitsProcessor(

688 - self.unpadded_vocab_size,

671 + config.vocab_size,

672 config.vocab_size,

673 scale=1 / self.config.logits_scaling,

674 )

vllm/model_executor/models/granitemoeshared.py

+5 -23

@@ -25,7 +25,6 @@ from vllm.model_executor.layers.linear import (

25 from vllm.model_executor.layers.logits_processor import LogitsProcessor

26 from vllm.model_executor.layers.quantization import QuantizationConfig

27 from vllm.model_executor.layers.vocab_parallel_embedding import (

28 - DEFAULT_VOCAB_PADDING_SIZE,

28 ParallelLMHead,

29 VocabParallelEmbedding,

30 )

@@ -159,23 +158,16 @@ class GraniteMoeSharedModel(nn.Module):

158 config = vllm_config.model_config.hf_config

159 cache_config = vllm_config.cache_config

160 quant_config = vllm_config.quant_config

162 - lora_config = vllm_config.lora_config

161

162 self.config = config

163 self.quant_config = quant_config # Required by MixtralModel

164 self.padding_idx = config.pad_token_id

167 - lora_vocab = (

168 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

169 - if lora_config

170 - else 0

171 - )

172 - self.vocab_size = config.vocab_size + lora_vocab

173 - self.org_vocab_size = config.vocab_size

165 +

166 + self.vocab_size = config.vocab_size

167

168 self.embed_tokens = VocabParallelEmbedding(

169 self.vocab_size,

170 config.hidden_size,

178 - org_num_embeddings=config.vocab_size,

171 quant_config=quant_config,

172 )

173 self.embedding_multiplier = config.embedding_multiplier

@@ -281,26 +273,16 @@ class GraniteMoeSharedForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

273 super().__init__()

274 config = vllm_config.model_config.hf_config

275 quant_config = vllm_config.quant_config

284 - lora_config = vllm_config.lora_config

276

277 self.config = config

287 - self.lora_config = lora_config

278

279 self.model = GraniteMoeSharedModel(

280 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

281 )

292 - self.unpadded_vocab_size = config.vocab_size

293 - if lora_config:

294 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

282 +

283 self.lm_head = ParallelLMHead(

296 - self.unpadded_vocab_size,

284 + config.vocab_size,

285 config.hidden_size,

298 - org_num_embeddings=config.vocab_size,

299 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

300 - # We need bigger padding if using lora for kernel

301 - # compatibility

302 - if not lora_config

303 - else lora_config.lora_vocab_padding_size,

286 quant_config=quant_config,

287 prefix=maybe_prefix(prefix, "lm_head"),

288 )

@@ -308,7 +290,7 @@ class GraniteMoeSharedForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

290 self.lm_head.weight = self.model.embed_tokens.weight

291

292 self.logits_processor = LogitsProcessor(

311 - self.unpadded_vocab_size,

293 + config.vocab_size,

294 config.vocab_size,

295 scale=1 / self.config.logits_scaling,

296 )

vllm/model_executor/models/grok1.py

+6 -20

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

45 from vllm.model_executor.layers.quantization import QuantizationConfig

46 from vllm.model_executor.layers.rotary_embedding import get_rope

47 from vllm.model_executor.layers.vocab_parallel_embedding import (

48 - DEFAULT_VOCAB_PADDING_SIZE,

48 ParallelLMHead,

49 VocabParallelEmbedding,

50 )

@@ -305,18 +304,13 @@ class Grok1Model(nn.Module):

304 config = vllm_config.model_config.hf_config

305 cache_config = vllm_config.cache_config

306 quant_config = vllm_config.quant_config

308 - lora_config = vllm_config.lora_config

307

308 self.config = config

309 self.quant_config = quant_config

310 self.padding_idx = config.pad_token_id

313 - lora_vocab = (

314 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

315 - if lora_config

316 - else 0

317 - )

318 - self.vocab_size = config.vocab_size + lora_vocab

319 - self.org_vocab_size = config.vocab_size

311 +

312 + self.vocab_size = config.vocab_size

313 +

314 self.embedding_multiplier_scale = getattr(

315 config, "embedding_multiplier_scale", DEFAULT_EMBEDDING_MULTIPLIER_SCALE

316 )

@@ -324,7 +318,6 @@ class Grok1Model(nn.Module):

318 self.embed_tokens = VocabParallelEmbedding(

319 self.vocab_size,

320 config.hidden_size,

327 - org_num_embeddings=config.vocab_size,

321 quant_config=quant_config,

322 )

323

@@ -499,25 +492,18 @@ class Grok1ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

492

493 config = vllm_config.model_config.hf_config

494 quant_config = vllm_config.quant_config

502 - lora_config = vllm_config.lora_config

495

496 self.config = config

505 - self.lora_config = lora_config

497 +

498 self.quant_config = quant_config

499

500 self.model = Grok1Model(

501 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

502 )

503

512 - self.unpadded_vocab_size = config.vocab_size

513 - if lora_config:

514 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

515 -

504 self.lm_head = ParallelLMHead(

517 - self.unpadded_vocab_size,

505 + config.vocab_size,

506 config.hidden_size,

519 - org_num_embeddings=config.vocab_size,

520 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

507 quant_config=quant_config,

508 prefix=maybe_prefix(prefix, "lm_head"),

509 )

@@ -529,7 +515,7 @@ class Grok1ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

515 config, "output_multiplier_scale", DEFAULT_OUTPUT_MULTIPLIER_SCALE

516 )

517 self.logits_processor = LogitsProcessor(

532 - self.unpadded_vocab_size, config.vocab_size, self.output_multiplier_scale

518 + config.vocab_size, scale=self.output_multiplier_scale

519 )

520

521 self.make_empty_intermediate_tensors = (

vllm/model_executor/models/hunyuan_v1.py

+6 -15

@@ -57,7 +57,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

57 from vllm.model_executor.layers.quantization import QuantizationConfig

58 from vllm.model_executor.layers.rotary_embedding import get_rope

59 from vllm.model_executor.layers.vocab_parallel_embedding import (

60 - DEFAULT_VOCAB_PADDING_SIZE,

60 ParallelLMHead,

61 VocabParallelEmbedding,

62 )

@@ -606,7 +605,7 @@ class HunYuanModel(nn.Module):

605 config = vllm_config.model_config.hf_config

606 cache_config = vllm_config.cache_config

607 quant_config = vllm_config.quant_config

609 - lora_config = vllm_config.lora_config

608 +

609 eplb_config = vllm_config.parallel_config.eplb_config

610 enable_eplb = vllm_config.parallel_config.enable_eplb

611 self.num_redundant_experts = eplb_config.num_redundant_experts

@@ -614,20 +613,15 @@ class HunYuanModel(nn.Module):

613 self.config = config

614 self.quant_config = quant_config

615 self.padding_idx = config.pad_token_id

617 - lora_vocab = (

618 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

619 - if lora_config

620 - else 0

621 - )

622 - self.vocab_size = config.vocab_size + lora_vocab

623 - self.org_vocab_size = config.vocab_size

616 +

617 + self.vocab_size = config.vocab_size

618 +

619 if get_pp_group().is_first_rank or (

620 config.tie_word_embeddings and get_pp_group().is_last_rank

621 ):

622 self.embed_tokens = VocabParallelEmbedding(

623 self.vocab_size,

624 config.hidden_size,

630 - org_num_embeddings=config.vocab_size,

625 quant_config=quant_config,

626 )

627 else:

@@ -937,12 +931,9 @@ class HunyuanV1ModelBase(nn.Module, SupportsLoRA, SupportsPP):

931

932 self.model = HunYuanModel(vllm_config=vllm_config, prefix="model")

933 if get_pp_group().is_last_rank:

940 - self.unpadded_vocab_size = config.vocab_size

934 self.lm_head = ParallelLMHead(

942 - self.unpadded_vocab_size,

935 + config.vocab_size,

936 config.hidden_size,

944 - org_num_embeddings=config.vocab_size,

945 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

937 quant_config=quant_config,

938 prefix=maybe_prefix(prefix, "lm_head"),

939 )

@@ -951,7 +942,7 @@ class HunyuanV1ModelBase(nn.Module, SupportsLoRA, SupportsPP):

942

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

944 self.logits_processor = LogitsProcessor(

954 - self.unpadded_vocab_size, config.vocab_size, logit_scale

945 + config.vocab_size, scale=logit_scale

946 )

947 else:

948 self.lm_head = PPMissingLayer()

vllm/model_executor/models/internlm2.py

-2

@@ -330,11 +330,9 @@ class InternLM2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

330 super().__init__()

331 config = vllm_config.model_config.hf_config

332 quant_config = vllm_config.quant_config

333 - lora_config = vllm_config.lora_config

333

334 self.config = config

335 self.quant_config = quant_config

337 - self.lora_config = lora_config

336

337 self.model = model_type(

338 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

vllm/model_executor/models/jamba.py

+6 -24

@@ -30,7 +30,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

30 from vllm.model_executor.layers.pooler import DispatchPooler, Pooler

31 from vllm.model_executor.layers.quantization import QuantizationConfig

32 from vllm.model_executor.layers.vocab_parallel_embedding import (

33 - DEFAULT_VOCAB_PADDING_SIZE,

33 ParallelLMHead,

34 VocabParallelEmbedding,

35 )

@@ -307,21 +306,14 @@ class JambaModel(nn.Module):

306 model_config = vllm_config.model_config

307 cache_config = vllm_config.cache_config

308 quant_config = vllm_config.quant_config

310 - lora_config = vllm_config.lora_config

309

310 self.config = config

313 - lora_vocab = (

314 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

315 - if lora_config

316 - else 0

317 - )

318 - self.vocab_size = config.vocab_size + lora_vocab

319 - self.org_vocab_size = config.vocab_size

311 +

312 + self.vocab_size = config.vocab_size

313

314 self.embed_tokens = VocabParallelEmbedding(

315 self.vocab_size,

316 config.hidden_size,

324 - org_num_embeddings=config.vocab_size,

317 )

318

319 extra_kwargs = {"is_lora_enabled": bool(vllm_config.lora_config)}

@@ -492,7 +484,7 @@ class JambaForCausalLM(

484

485 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

486 config = vllm_config.model_config.hf_config

495 - lora_config = vllm_config.lora_config

487 +

488 scheduler_config = vllm_config.scheduler_config

489

490 super().__init__()

@@ -503,24 +495,14 @@ class JambaForCausalLM(

495 self.model = JambaModel(

496 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

497 )

506 - self.unpadded_vocab_size = config.vocab_size

507 - if lora_config:

508 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

498 +

499 self.lm_head = ParallelLMHead(

510 - self.unpadded_vocab_size,

500 + config.vocab_size,

501 config.hidden_size,

512 - org_num_embeddings=config.vocab_size,

513 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

514 - # We need bigger padding if using lora for kernel

515 - # compatibility

516 - if not lora_config

517 - else lora_config.lora_vocab_padding_size,

502 prefix=maybe_prefix(prefix, "lm_head"),

503 )

504

521 - self.logits_processor = LogitsProcessor(

522 - self.unpadded_vocab_size, config.vocab_size

523 - )

505 + self.logits_processor = LogitsProcessor(config.vocab_size)

506

507 self.make_empty_intermediate_tensors = (

508 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/kimi_vl.py

+2 -8

@@ -60,7 +60,6 @@ from vllm.model_executor.layers.fused_moe import FusedMoE

60 from vllm.model_executor.layers.linear import ReplicatedLinear

61 from vllm.model_executor.layers.logits_processor import LogitsProcessor

62 from vllm.model_executor.layers.vocab_parallel_embedding import (

63 - DEFAULT_VOCAB_PADDING_SIZE,

63 ParallelLMHead,

64 )

65 from vllm.model_executor.model_loader.weight_utils import (

@@ -347,13 +346,10 @@ class KimiVLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP):

346 vllm_config=sub_vllm_config,

347 prefix=maybe_prefix(prefix, "language_model"),

348 )

350 - self.unpadded_vocab_size = config.text_config.vocab_size

349 if get_pp_group().is_last_rank:

350 self.lm_head = ParallelLMHead(

353 - self.unpadded_vocab_size,

351 + config.vocab_size,

352 config.text_config.hidden_size,

355 - org_num_embeddings=self.config.text_config.vocab_size,

356 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

353 prefix=maybe_prefix(prefix, "lm_head"),

354 )

355 else:

@@ -362,9 +358,7 @@ class KimiVLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP):

358 self.language_model.make_empty_intermediate_tensors

359 )

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

365 - self.logits_processor = LogitsProcessor(

366 - self.unpadded_vocab_size, config.vocab_size, logit_scale

367 - )

361 + self.logits_processor = LogitsProcessor(config.vocab_size, scale=logit_scale)

362 self.media_placeholder: int = self.config.media_placeholder_token_id

363

364 def _parse_and_validate_image_input(

vllm/model_executor/models/lfm2.py

+5 -26

@@ -28,7 +28,6 @@ from vllm.model_executor.layers.mamba.short_conv import ShortConv

28 from vllm.model_executor.layers.quantization import QuantizationConfig

29 from vllm.model_executor.layers.rotary_embedding import get_rope

30 from vllm.model_executor.layers.vocab_parallel_embedding import (

31 - DEFAULT_VOCAB_PADDING_SIZE,

31 ParallelLMHead,

32 VocabParallelEmbedding,

33 )

@@ -316,16 +315,10 @@ class Lfm2Model(nn.Module):

315 model_config = vllm_config.model_config

316 cache_config = vllm_config.cache_config

317 quant_config = vllm_config.quant_config

319 - lora_config = vllm_config.lora_config

318

319 self.config = config

322 - lora_vocab = (

323 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

324 - if lora_config

325 - else 0

326 - )

327 - self.vocab_size = config.vocab_size + lora_vocab

328 - self.org_vocab_size = config.vocab_size

320 +

321 + self.vocab_size = config.vocab_size

322

323 self.embed_tokens = VocabParallelEmbedding(

324 self.vocab_size, config.hidden_size, org_num_embeddings=config.vocab_size

@@ -483,7 +476,7 @@ class Lfm2ForCausalLM(

476 config = vllm_config.model_config.hf_config

477 quant_config = vllm_config.quant_config

478 cache_config = vllm_config.cache_config

486 - lora_config = vllm_config.lora_config

479 +

480 assert not cache_config.enable_prefix_caching, (

481 "Lfm2 currently does not support prefix caching"

482 )

@@ -495,21 +488,9 @@ class Lfm2ForCausalLM(

488 )

489

490 if get_pp_group().is_last_rank:

498 - self.unpadded_vocab_size = self.config.vocab_size

499 - if lora_config:

500 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

501 -

491 self.lm_head = ParallelLMHead(

503 - self.unpadded_vocab_size,

492 + config.vocab_size,

493 config.hidden_size,

505 - org_num_embeddings=config.vocab_size,

506 - padding_size=(

507 - DEFAULT_VOCAB_PADDING_SIZE

508 - # We need bigger padding if using lora for kernel

509 - # compatibility

510 - if not lora_config

511 - else lora_config.lora_vocab_padding_size

512 - ),

494 quant_config=quant_config,

495 prefix=maybe_prefix(prefix, "lm_head"),

496 )

@@ -517,9 +498,7 @@ class Lfm2ForCausalLM(

498 else:

499 self.lm_head = PPMissingLayer()

500

520 - self.logits_processor = LogitsProcessor(

521 - self.unpadded_vocab_size, config.vocab_size

522 - )

501 + self.logits_processor = LogitsProcessor(config.vocab_size)

502

503 self.make_empty_intermediate_tensors = (

504 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/lfm2_moe.py

+6 -26

@@ -33,7 +33,6 @@ from vllm.model_executor.layers.mamba.short_conv import ShortConv

33 from vllm.model_executor.layers.quantization import QuantizationConfig

34 from vllm.model_executor.layers.rotary_embedding import get_rope

35 from vllm.model_executor.layers.vocab_parallel_embedding import (

36 - DEFAULT_VOCAB_PADDING_SIZE,

36 ParallelLMHead,

37 VocabParallelEmbedding,

38 )

@@ -423,20 +422,15 @@ class Lfm2MoeModel(nn.Module):

422 model_config = vllm_config.model_config

423 cache_config = vllm_config.cache_config

424 quant_config = vllm_config.quant_config

426 - lora_config = vllm_config.lora_config

425 +

426 parallel_config = vllm_config.parallel_config

427 enable_eplb = parallel_config.enable_eplb

428 eplb_config = parallel_config.eplb_config

429 self.num_redundant_experts = eplb_config.num_redundant_experts

430

431 self.config = config

433 - lora_vocab = (

434 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

435 - if lora_config

436 - else 0

437 - )

438 - self.vocab_size = config.vocab_size + lora_vocab

439 - self.org_vocab_size = config.vocab_size

432 +

433 + self.vocab_size = config.vocab_size

434

435 self.embed_tokens = VocabParallelEmbedding(

436 self.vocab_size, config.hidden_size, org_num_embeddings=config.vocab_size

@@ -662,7 +656,7 @@ class Lfm2MoeForCausalLM(

656 config = vllm_config.model_config.hf_config

657 quant_config = vllm_config.quant_config

658 cache_config = vllm_config.cache_config

665 - lora_config = vllm_config.lora_config

659 +

660 assert not cache_config.enable_prefix_caching, (

661 "Lfm2Moe currently does not support prefix caching"

662 )

@@ -674,21 +668,9 @@ class Lfm2MoeForCausalLM(

668 )

669

670 if get_pp_group().is_last_rank:

677 - self.unpadded_vocab_size = self.config.vocab_size

678 - if lora_config:

679 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

680 -

671 self.lm_head = ParallelLMHead(

682 - self.unpadded_vocab_size,

672 + config.vocab_size,

673 config.hidden_size,

684 - org_num_embeddings=config.vocab_size,

685 - padding_size=(

686 - DEFAULT_VOCAB_PADDING_SIZE

687 - # We need bigger padding if using lora for kernel

688 - # compatibility

689 - if not lora_config

690 - else lora_config.lora_vocab_padding_size

691 - ),

674 quant_config=quant_config,

675 prefix=maybe_prefix(prefix, "lm_head"),

676 )

@@ -696,9 +678,7 @@ class Lfm2MoeForCausalLM(

678 else:

679 self.lm_head = PPMissingLayer()

680

699 - self.logits_processor = LogitsProcessor(

700 - self.unpadded_vocab_size, config.vocab_size

701 - )

681 + self.logits_processor = LogitsProcessor(config.vocab_size)

682

683 self.make_empty_intermediate_tensors = (

684 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/llama_eagle3.py

-3

@@ -15,7 +15,6 @@ from vllm.model_executor.layers.linear import QKVParallelLinear

15 from vllm.model_executor.layers.logits_processor import LogitsProcessor

16 from vllm.model_executor.layers.quantization.base_config import QuantizationConfig

17 from vllm.model_executor.layers.vocab_parallel_embedding import (

18 - DEFAULT_VOCAB_PADDING_SIZE,

18 ParallelLMHead,

19 VocabParallelEmbedding,

20 )

@@ -252,8 +251,6 @@ class Eagle3LlamaForCausalLM(LlamaForCausalLM):

251 self.lm_head = ParallelLMHead(

252 self.config.draft_vocab_size,

253 self.config.hidden_size,

255 - org_num_embeddings=self.config.draft_vocab_size,

256 - padding_size=(DEFAULT_VOCAB_PADDING_SIZE),

254 prefix=maybe_prefix(prefix, "lm_head"),

255 )

256 self.logits_processor = LogitsProcessor(

vllm/model_executor/models/longcat_flash.py

+1 -2

@@ -554,7 +554,6 @@ class LongcatFlashForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

554 super().__init__()

555 config = FlashConfig(**vllm_config.model_config.hf_config.__dict__)

556 quant_config = vllm_config.quant_config

557 - lora_config = vllm_config.lora_config

557

558 self.config = config

559 config.intermediate_size = (

@@ -562,7 +561,7 @@ class LongcatFlashForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

561 if hasattr(config, "ffn_hidden_size")

562 else config.intermediate_size

563 )

565 - self.lora_config = lora_config

564 +

565 self.quant_config = quant_config

566

567 self.model = FlashModel(

vllm/model_executor/models/mamba.py

+6 -23

@@ -21,7 +21,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

21 )

22 from vllm.model_executor.layers.quantization import QuantizationConfig

23 from vllm.model_executor.layers.vocab_parallel_embedding import (

24 - DEFAULT_VOCAB_PADDING_SIZE,

24 ParallelLMHead,

25 VocabParallelEmbedding,

26 )

@@ -110,18 +109,12 @@ class MambaModel(nn.Module):

109 is_lora_enabled = bool(lora_config)

110

111 self.config = config

113 - lora_vocab = (

114 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

115 - if lora_config

116 - else 0

117 - )

118 - self.vocab_size = config.vocab_size + lora_vocab

119 - self.org_vocab_size = config.vocab_size

112 +

113 + self.vocab_size = config.vocab_size

114

115 self.embeddings = VocabParallelEmbedding(

116 self.vocab_size,

117 config.hidden_size,

124 - org_num_embeddings=config.vocab_size,

118 )

119

120 self.start_layer, self.end_layer, self.layers = make_layers(

@@ -199,7 +192,7 @@ class MambaForCausalLM(

192 ):

193 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

194 config = vllm_config.model_config.hf_config

202 - lora_config = vllm_config.lora_config

195 +

196 self.scheduler_config = vllm_config.scheduler_config

197

198 super().__init__()

@@ -209,27 +202,17 @@ class MambaForCausalLM(

202 self.backbone = MambaModel(

203 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "backbone")

204 )

212 - self.unpadded_vocab_size = config.vocab_size

213 - if lora_config:

214 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

205 +

206 if config.tie_word_embeddings:

207 self.lm_head = self.backbone.embeddings

208 else:

209 self.lm_head = ParallelLMHead(

219 - self.unpadded_vocab_size,

210 + config.vocab_size,

211 config.hidden_size,

221 - org_num_embeddings=config.vocab_size,

222 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

223 - # We need bigger padding if using lora for kernel

224 - # compatibility

225 - if not lora_config

226 - else lora_config.lora_vocab_padding_size,

212 prefix=maybe_prefix(prefix, "lm_head"),

213 )

214

230 - self.logits_processor = LogitsProcessor(

231 - self.unpadded_vocab_size, config.vocab_size

232 - )

215 + self.logits_processor = LogitsProcessor(config.vocab_size)

216

217 self.make_empty_intermediate_tensors = (

218 self.backbone.make_empty_intermediate_tensors

vllm/model_executor/models/mamba2.py

+5 -23

@@ -20,7 +20,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

20 )

21 from vllm.model_executor.layers.quantization import QuantizationConfig

22 from vllm.model_executor.layers.vocab_parallel_embedding import (

23 - DEFAULT_VOCAB_PADDING_SIZE,

23 ParallelLMHead,

24 VocabParallelEmbedding,

25 )

@@ -107,18 +106,12 @@ class Mamba2Model(nn.Module):

106 assert not is_lora_enabled

107

108 self.config = config

110 - lora_vocab = (

111 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

112 - if lora_config

113 - else 0

114 - )

115 - self.vocab_size = config.vocab_size + lora_vocab

116 - self.org_vocab_size = config.vocab_size

109 +

110 + self.vocab_size = config.vocab_size

111

112 self.embeddings = VocabParallelEmbedding(

113 self.vocab_size,

114 config.hidden_size,

121 - org_num_embeddings=config.vocab_size,

115 )

116

117 self.start_layer, self.end_layer, self.layers = make_layers(

@@ -238,7 +231,7 @@ class Mamba2ForCausalLM(

231

232 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

233 config = vllm_config.model_config.hf_config

241 - lora_config = vllm_config.lora_config

234 +

235 scheduler_config = vllm_config.scheduler_config

236

237 super().__init__()

@@ -249,27 +242,16 @@ class Mamba2ForCausalLM(

242 self.backbone = Mamba2Model(

243 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "backbone")

244 )

252 - self.unpadded_vocab_size = config.vocab_size

253 - if lora_config:

254 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

245

246 self.lm_head = ParallelLMHead(

257 - self.unpadded_vocab_size,

247 + config.vocab_size,

248 config.hidden_size,

259 - org_num_embeddings=config.vocab_size,

260 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

261 - # We need bigger padding if using lora for kernel

262 - # compatibility

263 - if not lora_config

264 - else lora_config.lora_vocab_padding_size,

249 prefix=maybe_prefix(prefix, "lm_head"),

250 )

251 if config.tie_word_embeddings:

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

253

270 - self.logits_processor = LogitsProcessor(

271 - self.unpadded_vocab_size, config.vocab_size

272 - )

254 + self.logits_processor = LogitsProcessor(config.vocab_size)

255

256 self.make_empty_intermediate_tensors = (

257 self.backbone.make_empty_intermediate_tensors

vllm/model_executor/models/medusa.py

+3 -9

@@ -9,7 +9,6 @@ import torch.nn as nn

9 from vllm.config import VllmConfig

10 from vllm.model_executor.layers.logits_processor import LogitsProcessor

11 from vllm.model_executor.layers.vocab_parallel_embedding import (

12 - DEFAULT_VOCAB_PADDING_SIZE,

12 ParallelLMHead,

13 )

14 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

@@ -70,14 +69,11 @@ class Medusa(nn.Module):

69 )

70 self.orig_vocab_size = config.vocab_size

71 self.truncated_vocab_size = config.truncated_vocab_size

73 - self.unpadded_vocab_size = self.truncated_vocab_size

72

73 if getattr(config, "original_lm_head", False):

74 self.lm_head = ParallelLMHead(

77 - self.unpadded_vocab_size,

75 + self.truncated_vocab_size,

76 config.hidden_size,

79 - org_num_embeddings=self.truncated_vocab_size,

80 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

77 prefix=maybe_prefix(prefix, "lm_head"),

78 )

79 self.lm_heads = [self.lm_head for _ in range(self.config.num_heads)]

@@ -85,10 +81,8 @@ class Medusa(nn.Module):

81 self.lm_heads = nn.ModuleList(

82 [

83 ParallelLMHead(

88 - self.unpadded_vocab_size,

84 + config.vocab_size,

85 config.hidden_size,

90 - org_num_embeddings=self.truncated_vocab_size,

91 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

86 prefix=maybe_prefix(prefix, f"lm_heads.{i}"),

87 )

88 for i in range(self.config.num_heads)

@@ -97,7 +91,7 @@ class Medusa(nn.Module):

91

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

93 self.logits_processor = LogitsProcessor(

100 - self.unpadded_vocab_size, self.truncated_vocab_size, logit_scale

94 + config.vocab_size, self.truncated_vocab_size, logit_scale

95 )

96

97 # Token map is a idx to token mapping to reduce the vocab size for

vllm/model_executor/models/mimo.py

-2

@@ -151,10 +151,8 @@ class MiMoForCausalLM(Qwen2ForCausalLM, nn.Module):

151 nn.Module.__init__(self)

152 config = vllm_config.model_config.hf_config

153 quant_config = vllm_config.quant_config

154 - lora_config = vllm_config.lora_config

154

155 self.config = config

157 - self.lora_config = lora_config

156

157 self.quant_config = quant_config

158

vllm/model_executor/models/minicpm.py

+7 -23

@@ -55,7 +55,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

55 from vllm.model_executor.layers.quantization import QuantizationConfig

56 from vllm.model_executor.layers.rotary_embedding import get_rope

57 from vllm.model_executor.layers.vocab_parallel_embedding import (

58 - DEFAULT_VOCAB_PADDING_SIZE,

58 ParallelLMHead,

59 VocabParallelEmbedding,

60 )

@@ -405,22 +404,16 @@ class MiniCPMModel(nn.Module):

404 config = vllm_config.model_config.hf_config

405 cache_config = vllm_config.cache_config

406 quant_config = vllm_config.quant_config

408 - lora_config = vllm_config.lora_config

407

408 self.config = config

409 self.cache_config = cache_config

410 self.quant_config = quant_config

413 - lora_vocab = (

414 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

415 - if lora_config

416 - else 0

417 - )

418 - self.vocab_size = config.vocab_size + lora_vocab

419 - self.org_vocab_size = config.vocab_size

411 +

412 + self.vocab_size = config.vocab_size

413 +

414 self.embed_tokens = VocabParallelEmbedding(

415 self.vocab_size,

416 config.hidden_size,

423 - org_num_embeddings=config.vocab_size,

417 )

418 self.num_experts = getattr(self.config, "num_experts", 0)

419 self._init_layers(prefix, config, cache_config, quant_config)

@@ -588,13 +581,13 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

581 config = vllm_config.model_config.hf_config

582 cache_config = vllm_config.cache_config

583 quant_config = vllm_config.quant_config

591 - lora_config = vllm_config.lora_config

584 +

585 parallel_config = vllm_config.parallel_config

586

587 self.prefix = prefix

588 self.vllm_config = vllm_config

589 self.config = config

597 - self.lora_config = lora_config

590 +

591 self.cache_config = cache_config

592 self.quant_config = quant_config

593

@@ -602,18 +595,9 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

595 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

596 )

597

605 - unpadded_vocab_size = config.vocab_size

606 - if lora_config:

607 - unpadded_vocab_size += lora_config.lora_extra_vocab_size

598 self.lm_head = ParallelLMHead(

609 - unpadded_vocab_size,

599 + config.vocab_size,

600 config.hidden_size,

611 - org_num_embeddings=config.vocab_size,

612 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

613 - # We need bigger padding if using lora for kernel

614 - # compatibility

615 - if not lora_config

616 - else lora_config.lora_vocab_padding_size,

601 quant_config=quant_config,

602 prefix=maybe_prefix(prefix, "lm_head"),

603 )

@@ -621,7 +605,7 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

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

606 self.scale_width = self.config.hidden_size / self.config.dim_model_base

607

624 - self.logits_processor = LogitsProcessor(unpadded_vocab_size, config.vocab_size)

608 + self.logits_processor = LogitsProcessor(config.vocab_size)

609 self.make_empty_intermediate_tensors = (

610 self.model.make_empty_intermediate_tensors

611 )

vllm/model_executor/models/minicpm_eagle.py

+6 -23

@@ -37,7 +37,6 @@ from vllm.model_executor.layers.layernorm import RMSNorm

37 from vllm.model_executor.layers.logits_processor import LogitsProcessor

38 from vllm.model_executor.layers.quantization import QuantizationConfig

39 from vllm.model_executor.layers.vocab_parallel_embedding import (

40 - DEFAULT_VOCAB_PADDING_SIZE,

40 ParallelLMHead,

41 VocabParallelEmbedding,

42 )

@@ -151,18 +150,13 @@ class EagleMiniCPMModel(nn.Module):

150 config = vllm_config.speculative_config.draft_model_config.hf_config

151 cache_config = vllm_config.cache_config

152 quant_config = vllm_config.quant_config

154 - lora_config = vllm_config.lora_config

153

154 self.config = config

155 self.cache_config = cache_config

156 self.quant_config = quant_config

159 - lora_vocab = (

160 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

161 - if lora_config

162 - else 0

163 - )

164 - self.vocab_size = config.vocab_size + lora_vocab

165 - self.org_vocab_size = config.vocab_size

157 +

158 + self.vocab_size = config.vocab_size

159 +

160 self.fc = torch.nn.Linear(

161 self.config.hidden_size * 2, self.config.hidden_size, bias=False

162 )

@@ -171,7 +165,6 @@ class EagleMiniCPMModel(nn.Module):

165 self.embed_tokens = VocabParallelEmbedding(

166 self.vocab_size,

167 config.hidden_size,

174 - org_num_embeddings=config.vocab_size,

168 )

169 self.num_experts = getattr(self.config, "num_experts", 0)

170 self._init_layers(prefix, config, cache_config, quant_config, start_layer)

@@ -321,12 +314,11 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

314 config = vllm_config.speculative_config.draft_model_config.hf_config

315 cache_config = vllm_config.cache_config

316 quant_config = vllm_config.quant_config

324 - lora_config = vllm_config.lora_config

317

318 self.prefix = prefix

319 self.vllm_config = vllm_config

320 self.config = config

329 - self.lora_config = lora_config

321 +

322 self.cache_config = cache_config

323 self.quant_config = quant_config

324

@@ -340,18 +332,9 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

332 start_layer=target_layer_num,

333 )

334

343 - unpadded_vocab_size = config.vocab_size

344 - if lora_config:

345 - unpadded_vocab_size += lora_config.lora_extra_vocab_size

335 self.lm_head = ParallelLMHead(

347 - unpadded_vocab_size,

336 + config.vocab_size,

337 config.hidden_size,

349 - org_num_embeddings=config.vocab_size,

350 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

351 - # We need bigger padding if using lora for kernel

352 - # compatibility

353 - if not lora_config

354 - else lora_config.lora_vocab_padding_size,

338 quant_config=quant_config,

339 prefix=maybe_prefix(prefix, "lm_head"),

340 )

@@ -359,7 +342,7 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

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

343 self.scale_width = self.config.hidden_size / self.config.dim_model_base

344

362 - self.logits_processor = LogitsProcessor(unpadded_vocab_size, config.vocab_size)

345 + self.logits_processor = LogitsProcessor(config.vocab_size)

346 self.make_empty_intermediate_tensors = (

347 self.model.make_empty_intermediate_tensors

348 )

vllm/model_executor/models/minimax_text_01.py

+3 -8

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

41 from vllm.model_executor.layers.quantization import QuantizationConfig

42 from vllm.model_executor.layers.rotary_embedding import get_rope

43 from vllm.model_executor.layers.vocab_parallel_embedding import (

44 - DEFAULT_VOCAB_PADDING_SIZE,

44 ParallelLMHead,

45 VocabParallelEmbedding,

46 )

@@ -669,16 +668,14 @@ class MiniMaxText01ForCausalLM(nn.Module, HasInnerState, IsHybrid):

668 def __init__(self, *, vllm_config: VllmConfig, prefix: str = "") -> None:

669 super().__init__()

670 config = vllm_config.model_config.hf_config

672 - lora_config = vllm_config.lora_config

671 +

672 self.config = config

674 - self.lora_config = lora_config

673

674 if not hasattr(config, "sliding_window"):

675 config.sliding_window = None

676

677 self.CONCAT_FFN = True

678

681 - self.unpadded_vocab_size = self.config.vocab_size

679 if hasattr(vllm_config.model_config, "max_model_len"):

680 self.config.max_model_len = vllm_config.model_config.max_model_len

681 self.model = MiniMaxText01Model(

@@ -686,15 +683,13 @@ class MiniMaxText01ForCausalLM(nn.Module, HasInnerState, IsHybrid):

683 )

684 if get_pp_group().is_last_rank:

685 self.lm_head = ParallelLMHead(

689 - self.unpadded_vocab_size,

686 + config.vocab_size,

687 self.config.hidden_size,

691 - org_num_embeddings=self.config.vocab_size,

692 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

688 prefix=maybe_prefix(prefix, "lm_head"),

689 )

690

691 self.logits_processor = LogitsProcessor(

697 - self.unpadded_vocab_size, self.config.vocab_size

692 + config.vocab_size, self.config.vocab_size

693 )

694

695 else:

vllm/model_executor/models/mlp_speculator.py

-1

@@ -123,7 +123,6 @@ class MLPSpeculator(nn.Module):

123 VocabParallelEmbedding(

124 config.vocab_size,

125 self.inner_dim,

126 - org_num_embeddings=config.vocab_size,

126 )

127 for _ in range(self.max_speculative_tokens)

128 ]

vllm/model_executor/models/molmo.py

+1 -2

@@ -1404,10 +1404,9 @@ class MolmoForCausalLM(

1404 config = vllm_config.model_config.hf_config

1405 quant_config = vllm_config.quant_config

1406 multimodal_config = vllm_config.model_config.multimodal_config

1407 - lora_config = vllm_config.lora_config

1407 +

1408 self.config = config

1409 self.multimodal_config = multimodal_config

1410 - self.lora_config = lora_config

1410

1411 vision_config = VisionBackboneConfig()

1412 self.vision_backbone = MolmoVisionBackbone(config, vision_config, quant_config)

vllm/model_executor/models/nemotron.py

+7 -23

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

45 from vllm.model_executor.layers.quantization import QuantizationConfig

46 from vllm.model_executor.layers.rotary_embedding import get_rope

47 from vllm.model_executor.layers.vocab_parallel_embedding import (

48 - DEFAULT_VOCAB_PADDING_SIZE,

48 ParallelLMHead,

49 VocabParallelEmbedding,

50 )

@@ -319,24 +318,18 @@ class NemotronModel(nn.Module):

318 config = vllm_config.model_config.hf_config

319 cache_config = vllm_config.cache_config

320 quant_config = vllm_config.quant_config

322 - lora_config = vllm_config.lora_config

321

322 self.config = config

323 self.quant_config = quant_config

326 - lora_vocab = (

327 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

328 - if lora_config

329 - else 0

330 - )

331 - self.vocab_size = config.vocab_size + lora_vocab

332 - self.org_vocab_size = config.vocab_size

324 +

325 + self.vocab_size = config.vocab_size

326 +

327 if get_pp_group().is_first_rank or (

328 config.tie_word_embeddings and get_pp_group().is_last_rank

329 ):

330 self.embed_tokens = VocabParallelEmbedding(

331 self.vocab_size,

332 config.hidden_size,

339 - org_num_embeddings=config.vocab_size,

333 )

334 else:

335 self.embed_tokens = PPMissingLayer()

@@ -467,29 +460,20 @@ class NemotronForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

460 super().__init__()

461 config = vllm_config.model_config.hf_config

462 quant_config = vllm_config.quant_config

470 - lora_config = vllm_config.lora_config

463 +

464 assert isinstance(config, NemotronConfig)

465

466 self.config = config

474 - self.lora_config = lora_config

467 +

468 self.quant_config = quant_config

469

470 self.model = NemotronModel(

471 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

472 )

473 if get_pp_group().is_last_rank:

481 - self.unpadded_vocab_size = config.vocab_size

482 - if lora_config:

483 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

474 self.lm_head = ParallelLMHead(

485 - self.unpadded_vocab_size,

475 + config.vocab_size,

476 config.hidden_size,

487 - org_num_embeddings=config.vocab_size,

488 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

489 - # We need bigger padding if using lora for kernel

490 - # compatibility

491 - if not lora_config

492 - else lora_config.lora_vocab_padding_size,

477 quant_config=quant_config,

478 prefix=maybe_prefix(prefix, "lm_head"),

479 )

@@ -498,7 +482,7 @@ class NemotronForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

482

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

484 self.logits_processor = LogitsProcessor(

501 - self.unpadded_vocab_size, config.vocab_size, logit_scale

485 + config.vocab_size, scale=logit_scale

486 )

487 else:

488 self.lm_head = PPMissingLayer()

vllm/model_executor/models/nemotron_h.py

+6 -24

@@ -50,7 +50,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

50 )

51 from vllm.model_executor.layers.quantization import QuantizationConfig

52 from vllm.model_executor.layers.vocab_parallel_embedding import (

53 - DEFAULT_VOCAB_PADDING_SIZE,

53 ParallelLMHead,

54 VocabParallelEmbedding,

55 )

@@ -513,21 +512,14 @@ class NemotronHModel(nn.Module):

512 cache_config = vllm_config.cache_config

513 quant_config = vllm_config.quant_config

514 parallel_config = vllm_config.parallel_config

516 - lora_config = vllm_config.lora_config

515

516 self.config = config

519 - lora_vocab = (

520 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

521 - if lora_config

522 - else 0

523 - )

524 - self.vocab_size = config.vocab_size + lora_vocab

525 - self.org_vocab_size = config.vocab_size

517 +

518 + self.vocab_size = config.vocab_size

519

520 self.embed_tokens = VocabParallelEmbedding(

521 self.vocab_size,

522 config.hidden_size,

530 - org_num_embeddings=config.vocab_size,

523 )

524

525 self.has_moe = "E" in config.hybrid_override_pattern

@@ -768,7 +760,7 @@ class NemotronHForCausalLM(

760 config = vllm_config.model_config.hf_config

761 self.vllm_config = vllm_config

762 self.model_config = vllm_config.model_config

771 - lora_config = vllm_config.lora_config

763 +

764 scheduler_config = vllm_config.scheduler_config

765

766 self.quant_config = vllm_config.quant_config

@@ -779,24 +771,14 @@ class NemotronHForCausalLM(

771 self.model = NemotronHModel(

772 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

773 )

782 - self.unpadded_vocab_size = config.vocab_size

783 - if lora_config:

784 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

774 +

775 self.lm_head = ParallelLMHead(

786 - self.unpadded_vocab_size,

776 + config.vocab_size,

777 config.hidden_size,

788 - org_num_embeddings=config.vocab_size,

789 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

790 - # We need bigger padding if using lora for kernel

791 - # compatibility

792 - if not lora_config

793 - else lora_config.lora_vocab_padding_size,

778 prefix=maybe_prefix(prefix, "lm_head"),

779 )

780

797 - self.logits_processor = LogitsProcessor(

798 - self.unpadded_vocab_size, config.vocab_size

799 - )

781 + self.logits_processor = LogitsProcessor(config.vocab_size)

782

783 self.make_empty_intermediate_tensors = (

784 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/nemotron_nas.py

+6 -25

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

41 from vllm.model_executor.layers.quantization import QuantizationConfig

42 from vllm.model_executor.layers.rotary_embedding import get_rope

43 from vllm.model_executor.layers.vocab_parallel_embedding import (

44 - DEFAULT_VOCAB_PADDING_SIZE,

44 ParallelLMHead,

45 VocabParallelEmbedding,

46 )

@@ -250,25 +249,19 @@ class DeciModel(nn.Module):

249 config = vllm_config.model_config.hf_config

250 cache_config = vllm_config.cache_config

251 quant_config = vllm_config.quant_config

253 - lora_config = vllm_config.lora_config

252

253 self.config = config

254 self.quant_config = quant_config

255 self.padding_idx = config.pad_token_id

258 - lora_vocab = (

259 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

260 - if lora_config

261 - else 0

262 - )

263 - self.vocab_size = config.vocab_size + lora_vocab

264 - self.org_vocab_size = config.vocab_size

256 +

257 + self.vocab_size = config.vocab_size

258 +

259 if get_pp_group().is_first_rank or (

260 config.tie_word_embeddings and get_pp_group().is_last_rank

261 ):

262 self.embed_tokens = VocabParallelEmbedding(

263 self.vocab_size,

264 config.hidden_size,

271 - org_num_embeddings=config.vocab_size,

265 quant_config=quant_config,

266 )

267 else:

@@ -437,29 +430,17 @@ class DeciLMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, HasNoOps):

430 super().__init__()

431 config = vllm_config.model_config.hf_config

432 quant_config = vllm_config.quant_config

440 - lora_config = vllm_config.lora_config

433 +

434 self.config = config

442 - self.lora_config = lora_config

435

436 self.model = self._init_model(

437 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

438 )

439

440 if get_pp_group().is_last_rank:

449 - self.unpadded_vocab_size = config.vocab_size

450 - if lora_config:

451 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

441 self.lm_head = ParallelLMHead(

453 - self.unpadded_vocab_size,

442 + config.vocab_size,

443 config.hidden_size,

455 - org_num_embeddings=config.vocab_size,

456 - padding_size=(

457 - DEFAULT_VOCAB_PADDING_SIZE

458 - # We need bigger padding if using lora for kernel

459 - # compatibility

460 - if not lora_config

461 - else lora_config.lora_vocab_padding_size

462 - ),

444 quant_config=quant_config,

445 prefix=maybe_prefix(prefix, "lm_head"),

446 )

@@ -468,7 +449,7 @@ class DeciLMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, HasNoOps):

449

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

451 self.logits_processor = LogitsProcessor(

471 - self.unpadded_vocab_size, config.vocab_size, logit_scale

452 + config.vocab_size, scale=logit_scale

453 )

454 else:

455 self.lm_head = PPMissingLayer()

vllm/model_executor/models/olmo.py

+1 -3

@@ -368,11 +368,9 @@ class OlmoForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

368 if config.tie_word_embeddings:

369 self.lm_head = self.model.embed_tokens

370 else:

371 - self.unpadded_vocab_size = config.vocab_size

371 self.lm_head = ParallelLMHead(

373 - self.unpadded_vocab_size,

372 + config.vocab_size,

373 config.hidden_size,

375 - org_num_embeddings=config.vocab_size,

374 quant_config=quant_config,

375 prefix=maybe_prefix(prefix, "lm_head"),

376 )

vllm/model_executor/models/olmo2.py

-2

@@ -408,11 +408,9 @@ class Olmo2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

408 if config.tie_word_embeddings:

409 self.lm_head = self.model.embed_tokens

410 else:

411 - self.unpadded_vocab_size = config.vocab_size

411 self.lm_head = ParallelLMHead(

412 config.vocab_size,

413 config.hidden_size,

415 - org_num_embeddings=config.vocab_size,

414 quant_config=vllm_config.quant_config,

415 prefix=maybe_prefix(prefix, "lm_head"),

416 )

vllm/model_executor/models/ouro.py

-2

@@ -462,10 +462,8 @@ class OuroForCausalLM(nn.Module, SupportsLoRA):

462 super().__init__()

463 config = vllm_config.model_config.hf_config

464 quant_config = vllm_config.quant_config

465 - lora_config = vllm_config.lora_config

465

466 self.config = config

468 - self.lora_config = lora_config

467

468 self.quant_config = quant_config

469 self.model = OuroModel(

vllm/model_executor/models/phi.py

+1 -2

@@ -323,11 +323,10 @@ class PhiForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

323 super().__init__()

324 config = vllm_config.model_config.hf_config

325 quant_config = vllm_config.quant_config

326 - lora_config = vllm_config.lora_config

326 +

327 self.config = config

328 # lm_head use bias, cannot share word embeddings

329 assert not config.tie_word_embeddings

330 - self.lora_config = lora_config

330

331 self.quant_config = quant_config

332

vllm/model_executor/models/phi3v.py

-1

@@ -591,7 +591,6 @@ class Phi3VForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsQuant)

591 self.embed_tokens = VocabParallelEmbedding(

592 config.vocab_size,

593 config.hidden_size,

594 - org_num_embeddings=config.vocab_size,

594 quant_config=self.quant_config,

595 prefix=maybe_prefix(prefix, "model.embed_tokens"),

596 )

vllm/model_executor/models/phi4mm.py

+2 -12

@@ -21,7 +21,6 @@ from vllm.distributed import get_pp_group

21 from vllm.model_executor.layers.logits_processor import LogitsProcessor

22 from vllm.model_executor.layers.quantization import QuantizationConfig

23 from vllm.model_executor.layers.vocab_parallel_embedding import (

24 - DEFAULT_VOCAB_PADDING_SIZE,

24 ParallelLMHead,

25 )

26 from vllm.model_executor.models.llama import LlamaModel

@@ -1023,12 +1022,10 @@ class Phi4MMForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

1022 multimodal_config = vllm_config.model_config.multimodal_config

1023 assert multimodal_config, "multimodal_config is required"

1024 quant_config = vllm_config.quant_config

1026 - lora_config = vllm_config.lora_config

1025

1026 self.config = config

1027 self.multimodal_config = multimodal_config

1028 self.quant_config = quant_config

1031 - self.lora_config = lora_config

1029

1030 # Tensor/Pipeline parallel not supported for now.

1031 assert get_pp_group().world_size == 1, "pipeline parallel is not supported"

@@ -1055,23 +1052,16 @@ class Phi4MMForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

1052 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

1053 )

1054

1058 - self.unpadded_vocab_size = config.vocab_size

1059 - if lora_config:

1060 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

1055 self.lm_head = ParallelLMHead(

1062 - self.unpadded_vocab_size,

1056 + config.vocab_size,

1057 config.hidden_size,

1064 - org_num_embeddings=config.vocab_size,

1065 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

1058 quant_config=quant_config,

1059 prefix=maybe_prefix(prefix, "lm_head"),

1060 )

1061 if config.tie_word_embeddings:

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

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

1072 - self.logits_processor = LogitsProcessor(

1073 - self.unpadded_vocab_size, config.vocab_size, logit_scale

1074 - )

1064 + self.logits_processor = LogitsProcessor(config.vocab_size, scale=logit_scale)

1065

1066 def _parse_and_validate_audio_input(

1067 self, **kwargs: object

vllm/model_executor/models/phimoe.py

+7 -27

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

45 from vllm.model_executor.layers.quantization import QuantizationConfig

46 from vllm.model_executor.layers.rotary_embedding import get_rope

47 from vllm.model_executor.layers.vocab_parallel_embedding import (

48 - DEFAULT_VOCAB_PADDING_SIZE,

48 ParallelLMHead,

49 VocabParallelEmbedding,

50 )

@@ -458,22 +457,15 @@ class PhiMoEModel(nn.Module):

457 config = vllm_config.model_config.hf_config

458 cache_config = vllm_config.cache_config

459 quant_config = vllm_config.quant_config

461 - lora_config = vllm_config.lora_config

460

463 - lora_vocab = (

464 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

465 - if lora_config

466 - else 0

467 - )

468 - self.vocab_size = config.vocab_size + lora_vocab

469 - self.org_vocab_size = config.vocab_size

461 + self.vocab_size = config.vocab_size

462 +

463 self.config = config

464 self.quant_config = quant_config

465

466 self.embed_tokens = VocabParallelEmbedding(

467 self.vocab_size,

468 config.hidden_size,

476 - org_num_embeddings=config.vocab_size,

469 )

470 self.start_layer, self.end_layer, self.layers = make_layers(

471 config.num_hidden_layers,

@@ -634,35 +626,23 @@ class PhiMoEForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

626 def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):

627 super().__init__()

628 config = vllm_config.model_config.hf_config

637 - lora_config = vllm_config.lora_config

629 +

630 self.config = config

639 - self.lora_config = lora_config

631 +

632 self.quant_config = vllm_config.quant_config

633

634 self.model = PhiMoEModel(

635 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

636 )

645 - self.unpadded_vocab_size = config.vocab_size

646 - if lora_config:

647 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

637 +

638 self.lm_head = ParallelLMHead(

649 - self.unpadded_vocab_size,

639 + config.vocab_size,

640 config.hidden_size,

651 - org_num_embeddings=config.vocab_size,

652 - padding_size=(

653 - DEFAULT_VOCAB_PADDING_SIZE

654 - # We need bigger padding if using lora for kernel

655 - # compatibility

656 - if not lora_config

657 - else lora_config.lora_vocab_padding_size

658 - ),

641 quant_config=None,

642 bias=True,

643 prefix=maybe_prefix(prefix, "lm_head"),

644 )

663 - self.logits_processor = LogitsProcessor(

664 - self.unpadded_vocab_size, config.vocab_size

665 - )

645 + self.logits_processor = LogitsProcessor(config.vocab_size)

646

647 self.make_empty_intermediate_tensors = (

648 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/plamo2.py

+2 -9

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.mamba.ops.ssd_combined import (

46 from vllm.model_executor.layers.quantization import QuantizationConfig

47 from vllm.model_executor.layers.rotary_embedding import get_rope

48 from vllm.model_executor.layers.vocab_parallel_embedding import (

49 - DEFAULT_VOCAB_PADDING_SIZE,

49 ParallelLMHead,

50 VocabParallelEmbedding,

51 )

@@ -751,12 +750,10 @@ class Plamo2Model(torch.nn.Module):

750 self.config = config

751 self.padding_idx = config.pad_token_id

752 self.vocab_size = config.vocab_size

754 - self.org_vocab_size = config.vocab_size

753

754 self.embed_tokens = VocabParallelEmbedding(

755 self.vocab_size,

756 config.hidden_size,

759 - org_num_embeddings=config.vocab_size,

757 prefix=f"{prefix}.embed_tokens",

758 )

759 self.make_empty_intermediate_tensors = make_empty_intermediate_tensors_factory(

@@ -827,20 +824,16 @@ class Plamo2ForCausalLM(torch.nn.Module, HasInnerState, SupportsPP, IsHybrid):

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

825 )

826 self.vocab_size = self.config.vocab_size

830 - self.unpadded_vocab_size = self.config.vocab_size

831 - num_embeddings = ((self.vocab_size + 15) // 16) * 16

827 self.lm_head = ParallelLMHead(

833 - num_embeddings,

828 + self.vocab_size,

829 self.config.hidden_size,

835 - org_num_embeddings=self.config.vocab_size,

836 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

830 prefix=f"{prefix}.lm_head",

831 )

832 if self.config.tie_word_embeddings:

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

834

835 self.logits_processor = LogitsProcessor(

843 - self.unpadded_vocab_size, self.config.vocab_size

836 + config.vocab_size, self.config.vocab_size

837 )

838 self.make_empty_intermediate_tensors = (

839 self.model.make_empty_intermediate_tensors

vllm/model_executor/models/qwen2.py

-2

@@ -477,10 +477,8 @@ class Qwen2ForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

477 super().__init__()

478 config = vllm_config.model_config.hf_config

479 quant_config = vllm_config.quant_config

480 - lora_config = vllm_config.lora_config

480

481 self.config = config

483 - self.lora_config = lora_config

482

483 self.quant_config = quant_config

484 self.model = Qwen2Model(

vllm/model_executor/models/qwen2_rm.py

-2

@@ -43,10 +43,8 @@ class Qwen2RewardBaseModel(nn.Module, SupportsLoRA, SupportsPP):

43 super().__init__()

44 config = vllm_config.model_config.hf_config

45 quant_config = vllm_config.quant_config

46 - lora_config = vllm_config.lora_config

46

47 self.config = config

49 - self.lora_config = lora_config

48

49 self.quant_config = quant_config

50 self.model = Qwen2Model(

vllm/model_executor/models/qwen3.py

-2

@@ -272,10 +272,8 @@ class Qwen3ForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

272 super().__init__()

273 config = vllm_config.model_config.hf_config

274 quant_config = vllm_config.quant_config

275 - lora_config = vllm_config.lora_config

275

276 self.config = config

278 - self.lora_config = lora_config

277

278 self.quant_config = quant_config

279 self.model = Qwen3Model(

vllm/model_executor/models/qwen3_next.py

+7 -23

@@ -59,7 +59,6 @@ from vllm.model_executor.layers.mamba.ops.causal_conv1d import (

59 from vllm.model_executor.layers.quantization import QuantizationConfig

60 from vllm.model_executor.layers.rotary_embedding import get_rope

61 from vllm.model_executor.layers.vocab_parallel_embedding import (

62 - DEFAULT_VOCAB_PADDING_SIZE,

62 ParallelLMHead,

63 VocabParallelEmbedding,

64 )

@@ -967,22 +966,17 @@ class Qwen3NextModel(nn.Module):

966

967 config: Qwen3NextConfig = vllm_config.model_config.hf_config

968 parallel_config = vllm_config.parallel_config

970 - lora_config = vllm_config.lora_config

969 +

970 eplb_config = parallel_config.eplb_config

971 self.num_redundant_experts = eplb_config.num_redundant_experts

972

973 self.config = config

975 - lora_vocab = (

976 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

977 - if lora_config

978 - else 0

979 - )

980 - self.vocab_size = config.vocab_size + lora_vocab

974 +

975 + self.vocab_size = config.vocab_size

976

977 self.embed_tokens = VocabParallelEmbedding(

978 self.vocab_size,

979 config.hidden_size,

985 - org_num_embeddings=config.vocab_size,

980 )

981

982 def get_layer(prefix: str):

@@ -1196,7 +1190,7 @@ class Qwen3NextForCausalLM(

1190 self.vllm_config = vllm_config

1191 self.model_config = vllm_config.model_config

1192 cache_config = vllm_config.cache_config

1199 - lora_config = vllm_config.lora_config

1193 +

1194 scheduler_config = vllm_config.scheduler_config

1195 assert not cache_config.enable_prefix_caching, (

1196 "Qwen3Next currently does not support prefix caching"

@@ -1209,23 +1203,13 @@ class Qwen3NextForCausalLM(

1203 self.model = Qwen3NextModel(

1204 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

1205 )

1212 - self.unpadded_vocab_size = config.vocab_size

1213 - if lora_config:

1214 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

1206 +

1207 self.lm_head = ParallelLMHead(

1216 - self.unpadded_vocab_size,

1208 + config.vocab_size,

1209 config.hidden_size,

1218 - org_num_embeddings=config.vocab_size,

1219 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

1220 - # We need bigger padding if using lora for kernel

1221 - # compatibility

1222 - if not lora_config

1223 - else lora_config.lora_vocab_padding_size,

1210 prefix=maybe_prefix(prefix, "lm_head"),

1211 )

1226 - self.logits_processor = LogitsProcessor(

1227 - self.unpadded_vocab_size, config.vocab_size

1228 - )

1212 + self.logits_processor = LogitsProcessor(config.vocab_size)

1213 self.make_empty_intermediate_tensors = (

1214 self.model.make_empty_intermediate_tensors

1215 )

vllm/model_executor/models/qwen3_next_mtp.py

+6 -17

@@ -15,7 +15,6 @@ from vllm.model_executor.layers.fused_moe import FusedMoE

15 from vllm.model_executor.layers.linear import ColumnParallelLinear

16 from vllm.model_executor.layers.logits_processor import LogitsProcessor

17 from vllm.model_executor.layers.vocab_parallel_embedding import (

18 - DEFAULT_VOCAB_PADDING_SIZE,

18 ParallelLMHead,

19 VocabParallelEmbedding,

20 )

@@ -48,17 +47,12 @@ class Qwen3NextMultiTokenPredictor(nn.Module):

47

48 model_config = vllm_config.model_config

49 quant_config = vllm_config.quant_config

51 - lora_config = vllm_config.lora_config

50 +

51 config: Qwen3NextConfig = model_config.hf_config

52

53 self.config = config

55 - lora_vocab = (

56 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

57 - if lora_config

58 - else 0

59 - )

60 - self.vocab_size = config.vocab_size + lora_vocab

61 - self.org_vocab_size = config.vocab_size

54 +

55 + self.vocab_size = config.vocab_size

56

57 self.mtp_start_layer_idx = config.num_hidden_layers

58 self.num_mtp_layers = getattr(config, "num_nextn_predict_layers", 1)

@@ -66,7 +60,6 @@ class Qwen3NextMultiTokenPredictor(nn.Module):

60 self.embed_tokens = VocabParallelEmbedding(

61 self.vocab_size,

62 config.hidden_size,

69 - org_num_embeddings=config.vocab_size,

63 )

64

65 self.fc = ColumnParallelLinear(

@@ -252,17 +245,13 @@ class Qwen3NextMTP(nn.Module, SupportsPP, QwenNextMixtureOfExperts):

245 self.model = Qwen3NextMultiTokenPredictor(

246 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "mtp")

247 )

255 - self.unpadded_vocab_size = config.vocab_size

248 +

249 self.lm_head = ParallelLMHead(

257 - self.unpadded_vocab_size,

250 + config.vocab_size,

251 config.hidden_size,

259 - org_num_embeddings=config.vocab_size,

260 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

252 prefix=maybe_prefix(prefix, "lm_head"),

253 )

263 - self.logits_processor = LogitsProcessor(

264 - self.unpadded_vocab_size, config.vocab_size

265 - )

254 + self.logits_processor = LogitsProcessor(config.vocab_size)

255 self.make_empty_intermediate_tensors = (

256 self.model.make_empty_intermediate_tensors

257 )

vllm/model_executor/models/qwen3_vl.py

-2

@@ -1136,10 +1136,8 @@ class Qwen3LLMForCausalLM(Qwen3ForCausalLM):

1136 super(Qwen3ForCausalLM, self).__init__()

1137 config = vllm_config.model_config.hf_config.text_config

1138 quant_config = vllm_config.quant_config

1139 - lora_config = vllm_config.lora_config

1139

1140 self.config = config

1142 - self.lora_config = lora_config

1141

1142 self.quant_config = quant_config

1143 self.model = Qwen3LLMModel(vllm_config=vllm_config, prefix=prefix)

vllm/model_executor/models/seed_oss.py

-2

@@ -440,10 +440,8 @@ class SeedOssForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

440 super().__init__()

441 config = vllm_config.model_config.hf_config

442 quant_config = vllm_config.quant_config

443 - lora_config = vllm_config.lora_config

443

444 self.config = config

446 - self.lora_config = lora_config

445

446 self.quant_config = quant_config

447 self.model = SeedOssModel(

vllm/model_executor/models/solar.py

+7 -23

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

46 from vllm.model_executor.layers.quantization import QuantizationConfig

47 from vllm.model_executor.layers.rotary_embedding import get_rope

48 from vllm.model_executor.layers.vocab_parallel_embedding import (

49 - DEFAULT_VOCAB_PADDING_SIZE,

49 ParallelLMHead,

50 VocabParallelEmbedding,

51 )

@@ -277,24 +276,18 @@ class SolarModel(nn.Module):

276 config = vllm_config.model_config.hf_config

277 cache_config = vllm_config.cache_config

278 quant_config = vllm_config.quant_config

280 - lora_config = vllm_config.lora_config

279

280 self.config = config

281 self.quant_config = quant_config

284 - lora_vocab = (

285 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

286 - if lora_config

287 - else 0

288 - )

289 - self.vocab_size = config.vocab_size + lora_vocab

290 - self.org_vocab_size = config.vocab_size

282 +

283 + self.vocab_size = config.vocab_size

284 +

285 if get_pp_group().is_first_rank or (

286 config.tie_word_embeddings and get_pp_group().is_last_rank

287 ):

288 self.embed_tokens = VocabParallelEmbedding(

289 self.vocab_size,

290 config.hidden_size,

297 - org_num_embeddings=config.vocab_size,

291 )

292 else:

293 self.embed_tokens = PPMissingLayer()

@@ -455,9 +448,9 @@ class SolarForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

448 super().__init__()

449 config = vllm_config.model_config.hf_config

450 quant_config = vllm_config.quant_config

458 - lora_config = vllm_config.lora_config

451 +

452 self.config = config

460 - self.lora_config = lora_config

453 +

454 self.quant_config = quant_config

455

456 self.model = SolarModel(

@@ -465,18 +458,9 @@ class SolarForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

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

459 )

460 if get_pp_group().is_last_rank:

468 - self.unpadded_vocab_size = config.vocab_size

469 - if lora_config:

470 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

461 self.lm_head = ParallelLMHead(

472 - self.unpadded_vocab_size,

462 + config.vocab_size,

463 config.hidden_size,

474 - org_num_embeddings=config.vocab_size,

475 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

476 - # We need bigger padding if using lora for kernel

477 - # compatibility

478 - if not lora_config

479 - else lora_config.lora_vocab_padding_size,

464 quant_config=quant_config,

465 prefix=maybe_prefix(prefix, "lm_head"),

466 )

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

469

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

471 self.logits_processor = LogitsProcessor(

488 - self.unpadded_vocab_size, config.vocab_size, logit_scale

472 + config.vocab_size, scale=logit_scale

473 )

474 else:

475 self.lm_head = PPMissingLayer()

vllm/model_executor/models/starcoder2.py

+3 -9

@@ -42,7 +42,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

42 from vllm.model_executor.layers.quantization import QuantizationConfig

43 from vllm.model_executor.layers.rotary_embedding import get_rope

44 from vllm.model_executor.layers.vocab_parallel_embedding import (

45 - DEFAULT_VOCAB_PADDING_SIZE,

45 ParallelLMHead,

46 VocabParallelEmbedding,

47 )

@@ -319,22 +318,17 @@ class Starcoder2ForCausalLM(nn.Module, SupportsPP):

318 vllm_config=vllm_config, prefix=maybe_prefix(prefix, "model")

319 )

320 self.vocab_size = config.vocab_size

322 - self.unpadded_vocab_size = config.vocab_size

321 +

322 if config.tie_word_embeddings:

323 self.lm_head = self.model.embed_tokens

324 else:

326 - self.unpadded_vocab_size = config.vocab_size

325 self.lm_head = ParallelLMHead(

328 - self.unpadded_vocab_size,

326 + config.vocab_size,

327 config.hidden_size,

330 - org_num_embeddings=config.vocab_size,

331 - padding_size=DEFAULT_VOCAB_PADDING_SIZE,

328 quant_config=quant_config,

329 prefix=f"{prefix}.lm_head",

330 )

335 - self.logits_processor = LogitsProcessor(

336 - self.unpadded_vocab_size, config.vocab_size

337 - )

331 + self.logits_processor = LogitsProcessor(config.vocab_size)

332 self.make_empty_intermediate_tensors = (

333 self.model.make_empty_intermediate_tensors

334 )

vllm/model_executor/models/step3_text.py

+3 -13

@@ -31,7 +31,6 @@ from vllm.model_executor.layers.logits_processor import LogitsProcessor

31 from vllm.model_executor.layers.quantization import QuantizationConfig

32 from vllm.model_executor.layers.rotary_embedding import get_rope

33 from vllm.model_executor.layers.vocab_parallel_embedding import (

34 - DEFAULT_VOCAB_PADDING_SIZE,

34 ParallelLMHead,

35 VocabParallelEmbedding,

36 )

@@ -400,28 +399,19 @@ class Step3TextForCausalLM(nn.Module, SupportsPP):

399 ):

400 super().__init__()

401 config = vllm_config.model_config.hf_config

403 - lora_config = vllm_config.lora_config

402 +

403 self.config = config

404 self.vllm_config = vllm_config

405

406 self.model = Step3TextModel(vllm_config=vllm_config, prefix=prefix)

407

408 if get_pp_group().is_last_rank:

410 - self.unpadded_vocab_size = config.vocab_size

411 - if lora_config:

412 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

409 self.lm_head = ParallelLMHead(

414 - self.unpadded_vocab_size,

410 + config.vocab_size,

411 config.hidden_size,

416 - org_num_embeddings=config.vocab_size,

417 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

418 - if not lora_config

419 - else lora_config.lora_vocab_padding_size,

412 prefix=maybe_prefix(prefix, "lm_head"),

413 )

422 - self.logits_processor = LogitsProcessor(

423 - self.unpadded_vocab_size, config.vocab_size

424 - )

414 + self.logits_processor = LogitsProcessor(config.vocab_size)

415 else:

416 self.lm_head = PPMissingLayer()

417

vllm/model_executor/models/transformers/causal.py

+1 -2

@@ -42,7 +42,6 @@ class CausalMixin(VllmModelForTextGeneration):

42 self.skip_prefixes.append("lm_head.")

43

44 if self.pp_group.is_last_rank:

45 - self.unpadded_vocab_size = self.text_config.vocab_size

45 self.lm_head = ParallelLMHead(

46 self.text_config.vocab_size,

47 self.text_config.hidden_size,

@@ -56,7 +55,7 @@ class CausalMixin(VllmModelForTextGeneration):

55

56 logit_scale = getattr(self.text_config, "logit_scale", 1.0)

57 self.logits_processor = LogitsProcessor(

59 - self.unpadded_vocab_size, self.text_config.vocab_size, logit_scale

58 + self.text_config.vocab_size, scale=logit_scale

59 )

60 else:

61 self.lm_head = PPMissingLayer()

vllm/model_executor/models/whisper.py

+2 -4

@@ -890,7 +890,7 @@ class WhisperForConditionalGeneration(

890 self.dtype = vllm_config.model_config.dtype

891

892 self.model = WhisperModel(vllm_config=vllm_config, prefix=prefix)

893 - self.unpadded_vocab_size = config.vocab_size

893 +

894 self.proj_out = ParallelLMHead(

895 config.vocab_size,

896 config.d_model,

@@ -899,9 +899,7 @@ class WhisperForConditionalGeneration(

899 )

900 self.proj_out = self.proj_out.tie_weights(self.model.decoder.embed_tokens)

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

902 - self.logits_processor = LogitsProcessor(

903 - self.unpadded_vocab_size, config.vocab_size, logit_scale

904 - )

902 + self.logits_processor = LogitsProcessor(config.vocab_size, scale=logit_scale)

903

904 def forward(

905 self,

vllm/model_executor/models/zamba2.py

+5 -23

@@ -38,7 +38,6 @@ from vllm.model_executor.layers.mamba.mamba_utils import (

38 from vllm.model_executor.layers.quantization import QuantizationConfig

39 from vllm.model_executor.layers.rotary_embedding import get_rope

40 from vllm.model_executor.layers.vocab_parallel_embedding import (

41 - DEFAULT_VOCAB_PADDING_SIZE,

41 ParallelLMHead,

42 VocabParallelEmbedding,

43 )

@@ -692,19 +691,13 @@ class Zamba2Model(nn.Module):

691 assert not is_lora_enabled

692

693 self.config = config

695 - lora_vocab = (

696 - (lora_config.lora_extra_vocab_size * (lora_config.max_loras or 1))

697 - if lora_config

698 - else 0

699 - )

700 - self.vocab_size = config.vocab_size + lora_vocab

701 - self.org_vocab_size = config.vocab_size

694 +

695 + self.vocab_size = config.vocab_size

696

697 # Initialize token embeddings

698 self.embed_tokens = VocabParallelEmbedding(

699 self.vocab_size,

700 config.hidden_size,

707 - org_num_embeddings=config.vocab_size,

701 )

702

703 # Map hybrid layer indices to block indices

@@ -911,7 +904,7 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsMambaPrefixC

904 (not supported by Mamba)

905 """

906 config = vllm_config.model_config.hf_config

914 - lora_config = vllm_config.lora_config

907 +

908 scheduler_config = vllm_config.scheduler_config

909

910 super().__init__()

@@ -919,9 +912,6 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsMambaPrefixC

912 self.vllm_config = vllm_config

913 self.scheduler_config = scheduler_config

914 self.model_config = vllm_config.model_config

922 - self.unpadded_vocab_size = config.vocab_size

923 - if lora_config:

924 - self.unpadded_vocab_size += lora_config.lora_extra_vocab_size

915

916 # Initialize core model

917 self.model = Zamba2Model(

@@ -930,23 +920,15 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsMambaPrefixC

920

921 # Initialize language modeling head

922 self.lm_head = ParallelLMHead(

933 - self.unpadded_vocab_size,

923 + config.vocab_size,

924 config.hidden_size,

935 - org_num_embeddings=config.vocab_size,

936 - padding_size=DEFAULT_VOCAB_PADDING_SIZE

937 - # We need bigger padding if using lora for kernel

938 - # compatibility

939 - if not lora_config

940 - else lora_config.lora_vocab_padding_size,

925 prefix=maybe_prefix(prefix, "lm_head"),

926 )

927 # Tie weights with input embeddings if using same dimensions

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

929

930 # Initialize logits processing and sampling

947 - self.logits_processor = LogitsProcessor(

948 - self.unpadded_vocab_size, config.vocab_size

949 - )

931 + self.logits_processor = LogitsProcessor(config.vocab_size)

932

933 def get_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:

934 """Convert input token IDs to embeddings.

[LoRA][1/N]Remove LoRA extra vocab (#28382)