97d1c99302 · tduncan/Nvidia-Optimization-Stack-VLLM

docs/contributing/model/basic.md

+2 -2

@@ -56,13 +56,13 @@ The initialization code should look like this:

56

57 ### Computation Code

58

59 -- Add a `get_input_embeddings` method inside `MyModel` module that returns the text embeddings given `input_ids`. This is equivalent to directly calling the text embedding layer, but provides a unified interface in case `MyModel` is used within a composite multimodal model.

59 +- Add a `embed_input_ids` method inside `MyModel` module that returns the text embeddings given `input_ids`. This is equivalent to directly calling the text embedding layer, but provides a unified interface in case `MyModel` is used within a composite multimodal model.

60

61 ```python

62 class MyModel(nn.Module):

63 ...

64

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

65 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

66 ...

67 ```

68

docs/contributing/model/multimodal.md

+3 -3

@@ -36,7 +36,7 @@ Further update the model as follows:

36

37 More conveniently, you can simply pass `**kwargs` to the [forward][torch.nn.Module.forward] method and retrieve the keyword parameters for multimodal inputs from it.

38

39 -- Implement [get_multimodal_embeddings][vllm.model_executor.models.interfaces.SupportsMultiModal.get_multimodal_embeddings] that returns the embeddings from running the multimodal inputs through the multimodal tokenizer of the model. Below we provide a boilerplate of a typical implementation pattern, but feel free to adjust it to your own needs.

39 +- Implement [embed_multimodal][vllm.model_executor.models.interfaces.SupportsMultiModal.embed_multimodal] that returns the embeddings from running the multimodal inputs through the multimodal tokenizer of the model. Below we provide a boilerplate of a typical implementation pattern, but feel free to adjust it to your own needs.

40

41 ??? code

42

@@ -49,7 +49,7 @@ Further update the model as follows:

49 image_features = self.vision_encoder(image_input)

50 return self.multi_modal_projector(image_features)

51

52 - def get_multimodal_embeddings(

52 + def embed_multimodal(

53 self,

54 **kwargs: object,

55 ) -> MultiModalEmbeddings | None:

@@ -69,7 +69,7 @@ Further update the model as follows:

69 !!! note

70 By default, vLLM merges the multimodal embeddings into text embeddings depending on the information of their locations defined in

71 [PlaceholderRange][vllm.multimodal.inputs.PlaceholderRange] from input processing.

72 - This logic can be found at [get_input_embeddings][vllm.model_executor.models.interfaces.SupportsMultiModal.get_input_embeddings].

72 + This logic can be found at [embed_input_ids][vllm.model_executor.models.interfaces.SupportsMultiModal.embed_input_ids].

73

74 You may override this method if additional logic is required for your model when merging embeddings.

75

vllm/model_executor/models/apertus.py

+4 -4

@@ -382,7 +382,7 @@ class ApertusModel(nn.Module):

382 ["hidden_states", "residual"], config.hidden_size

383 )

384

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

385 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

386 return self.embed_tokens(input_ids)

387

388 def forward(

@@ -396,7 +396,7 @@ class ApertusModel(nn.Module):

396 if inputs_embeds is not None:

397 hidden_states = inputs_embeds

398 else:

399 - hidden_states = self.get_input_embeddings(input_ids)

399 + hidden_states = self.embed_input_ids(input_ids)

400 residual = None

401 else:

402 assert intermediate_tensors is not None

@@ -557,8 +557,8 @@ class ApertusForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

557 vllm_config=vllm_config, prefix=prefix, layer_type=layer_type

558 )

559

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

561 - return self.model.get_input_embeddings(input_ids)

560 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

561 + return self.model.embed_input_ids(input_ids)

562

563 def forward(

564 self,

vllm/model_executor/models/arcee.py

+4 -4

@@ -239,7 +239,7 @@ class ArceeModel(nn.Module):

239 ["hidden_states", "residual"], config.hidden_size

240 )

241

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

242 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

243 return self.embed_tokens(input_ids)

244

245 def forward(

@@ -254,7 +254,7 @@ class ArceeModel(nn.Module):

254 hidden_states = (

255 inputs_embeds

256 if inputs_embeds is not None

257 - else self.get_input_embeddings(input_ids)

257 + else self.embed_input_ids(input_ids)

258 )

259 residual = None

260 else:

@@ -423,8 +423,8 @@ class ArceeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

423 logits = self.logits_processor(self.lm_head, hidden_states)

424 return logits

425

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

427 - return self.model.get_input_embeddings(input_ids)

426 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

427 + return self.model.embed_input_ids(input_ids)

428

429 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:

430 """Load weights into the model (delegates to inner model and handles

vllm/model_executor/models/arctic.py

+4 -4

@@ -442,7 +442,7 @@ class ArcticModel(nn.Module):

442 ["hidden_states"], config.hidden_size

443 )

444

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

445 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

446 return self.embed_tokens(input_ids)

447

448 def forward(

@@ -456,7 +456,7 @@ class ArcticModel(nn.Module):

456 if inputs_embeds is not None:

457 hidden_states = inputs_embeds

458 else:

459 - hidden_states = self.get_input_embeddings(input_ids)

459 + hidden_states = self.embed_input_ids(input_ids)

460 else:

461 assert intermediate_tensors is not None

462 hidden_states = intermediate_tensors["hidden_states"]

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

496 self.model.make_empty_intermediate_tensors

497 )

498

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

500 - return self.model.get_input_embeddings(input_ids)

499 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

500 + return self.model.embed_input_ids(input_ids)

501

502 def forward(

503 self,

vllm/model_executor/models/aria.py

+3 -3

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

613 def get_language_model(self) -> torch.nn.Module:

614 return self.language_model

615

616 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

616 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

617 image_input = self._parse_and_validate_image_input(**kwargs)

618 if image_input is None:

619 return []

@@ -629,8 +629,8 @@ class AriaForConditionalGeneration(nn.Module, SupportsMultiModal):

629 **kwargs: object,

630 ) -> torch.Tensor | IntermediateTensors:

631 if inputs_embeds is None:

632 - multimodal_embeddings = self.get_multimodal_embeddings(**kwargs)

633 - inputs_embeds = self.get_input_embeddings(

632 + multimodal_embeddings = self.embed_multimodal(**kwargs)

633 + inputs_embeds = self.embed_input_ids(

634 input_ids,

635 multimodal_embeddings,

636 is_multimodal=input_ids == self.config.image_token_index,

vllm/model_executor/models/aya_vision.py

+1 -1

@@ -417,7 +417,7 @@ class AyaVisionForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsP

417 def get_language_model(self) -> torch.nn.Module:

418 return self.language_model

419

420 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

420 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

421 image_input = self._parse_and_validate_image_input(**kwargs)

422 if image_input is None:

423 return []

vllm/model_executor/models/baichuan.py

+4 -4

@@ -309,7 +309,7 @@ class BaiChuanModel(nn.Module):

309 ["hidden_states", "residual"], config.hidden_size

310 )

311

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

312 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

313 return self.embed_tokens(input_ids)

314

315 def forward(

@@ -323,7 +323,7 @@ class BaiChuanModel(nn.Module):

323 if inputs_embeds is not None:

324 hidden_states = inputs_embeds

325 else:

326 - hidden_states = self.get_input_embeddings(input_ids)

326 + hidden_states = self.embed_input_ids(input_ids)

327 residual = None

328 else:

329 assert intermediate_tensors is not None

@@ -426,8 +426,8 @@ class BaiChuanBaseForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsQuant

426 self.model.make_empty_intermediate_tensors

427 )

428

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

430 - return self.model.get_input_embeddings(input_ids)

429 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

430 + return self.model.embed_input_ids(input_ids)

431

432 def forward(

433 self,

vllm/model_executor/models/bailing_moe.py

+4 -4

@@ -438,7 +438,7 @@ class BailingMoeModel(nn.Module):

438 else:

439 self.norm = PPMissingLayer()

440

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

441 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

442 return self.word_embeddings(input_ids)

443

444 def forward(

@@ -452,7 +452,7 @@ class BailingMoeModel(nn.Module):

452 if inputs_embeds is not None:

453 hidden_states = inputs_embeds

454 else:

455 - hidden_states = self.get_input_embeddings(input_ids)

455 + hidden_states = self.embed_input_ids(input_ids)

456 residual = None

457 else:

458 assert intermediate_tensors is not None

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

608 self.model.make_empty_intermediate_tensors

609 )

610

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

612 - return self.model.get_input_embeddings(input_ids)

611 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

612 + return self.model.embed_input_ids(input_ids)

613

614 def forward(

615 self,

vllm/model_executor/models/bamba.py

+4 -4

@@ -314,7 +314,7 @@ class BambaModel(nn.Module):

314

315 self.final_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

316

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

317 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

318 return self.embed_tokens(input_ids)

319

320 def forward(

@@ -328,7 +328,7 @@ class BambaModel(nn.Module):

328 if inputs_embeds is not None:

329 hidden_states = inputs_embeds

330 else:

331 - hidden_states = self.get_input_embeddings(input_ids)

331 + hidden_states = self.embed_input_ids(input_ids)

332 residual = None

333 else:

334 assert intermediate_tensors is not None

@@ -493,8 +493,8 @@ class BambaForCausalLM(

493 self.model.make_empty_intermediate_tensors

494 )

495

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

497 - return self.model.get_input_embeddings(input_ids)

496 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

497 + return self.model.embed_input_ids(input_ids)

498

499 def forward(

500 self,

vllm/model_executor/models/bert.py

+7 -7

@@ -375,7 +375,7 @@ class BertModel(nn.Module, SupportsQuant):

375 self.embeddings = embedding_class(self.config)

376 self.encoder = BertEncoder(vllm_config=vllm_config, prefix=f"{prefix}.encoder")

377

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

378 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

379 return self.embeddings.word_embeddings(input_ids)

380

381 def forward(

@@ -486,8 +486,8 @@ class BertEmbeddingModel(nn.Module, SupportsQuant):

486 )

487 self.pooler = self._build_pooler(pooler_config)

488

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

490 - return self.model.get_input_embeddings(input_ids)

489 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

490 + return self.model.embed_input_ids(input_ids)

491

492 def forward(

493 self,

@@ -835,8 +835,8 @@ class BertForSequenceClassification(nn.Module, SupportsCrossEncoding, SupportsQu

835 }

836 )

837

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

839 - return self.bert.get_input_embeddings(input_ids)

838 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

839 + return self.bert.embed_input_ids(input_ids)

840

841 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):

842 loader = AutoWeightsLoader(self)

@@ -893,8 +893,8 @@ class BertForTokenClassification(nn.Module):

893 }

894 )

895

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

897 - return self.bert.get_input_embeddings(input_ids)

896 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

897 + return self.bert.embed_input_ids(input_ids)

898

899 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):

900 loader = AutoWeightsLoader(self)

vllm/model_executor/models/bert_with_rope.py

+3 -3

@@ -463,7 +463,7 @@ class BertWithRope(nn.Module, SupportsQuant):

463 )

464 self.pooler = BertPooler(self.config) if add_pooling_layer else None

465

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

466 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

467 return self.embeddings(input_ids)

468

469 def forward(

@@ -714,8 +714,8 @@ class GteNewForSequenceClassification(nn.Module, SupportsCrossEncoding):

714 loaded_params = loader.load_weights(weights)

715 return loaded_params

716

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

718 - return self.new.get_input_embeddings(input_ids)

717 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

718 + return self.new.embed_input_ids(input_ids)

719

720 def forward(

721 self,

vllm/model_executor/models/blip2.py

+1 -1

@@ -630,7 +630,7 @@ class Blip2ForConditionalGeneration(

630 def get_language_model(self) -> torch.nn.Module:

631 return self.language_model

632

633 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

633 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

634 image_input = self._parse_and_validate_image_input(**kwargs)

635 if image_input is None:

636 return []

vllm/model_executor/models/bloom.py

+4 -4

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

271 ["hidden_states"], config.hidden_size

272 )

273

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

274 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

275 return self.word_embeddings(input_ids)

276

277 def forward(

@@ -285,7 +285,7 @@ class BloomModel(nn.Module):

285 if inputs_embeds is not None:

286 hidden_states = inputs_embeds

287 else:

288 - hidden_states = self.get_input_embeddings(input_ids)

288 + hidden_states = self.embed_input_ids(input_ids)

289 hidden_states = self.word_embeddings_layernorm(hidden_states)

290 else:

291 assert intermediate_tensors is not None

@@ -353,8 +353,8 @@ class BloomForCausalLM(nn.Module, SupportsPP, SupportsQuant):

353 self.transformer.make_empty_intermediate_tensors

354 )

355

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

357 - return self.transformer.get_input_embeddings(input_ids)

356 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

357 + return self.transformer.embed_input_ids(input_ids)

358

359 def forward(

360 self,

vllm/model_executor/models/chameleon.py

+4 -4

@@ -886,7 +886,7 @@ class ChameleonModel(nn.Module):

886 ["hidden_states", "residual"], config.hidden_size

887 )

888

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

889 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

890 return self.embed_tokens(input_ids)

891

892 def get_image_tokens(self, pixel_values: torch.Tensor) -> torch.Tensor:

@@ -912,7 +912,7 @@ class ChameleonModel(nn.Module):

912 if inputs_embeds is not None:

913 hidden_states = inputs_embeds

914 else:

915 - hidden_states = self.get_input_embeddings(input_ids)

915 + hidden_states = self.embed_input_ids(input_ids)

916 residual = None

917 else:

918 assert intermediate_tensors is not None

@@ -998,7 +998,7 @@ class ChameleonForConditionalGeneration(

998 def get_language_model(self) -> torch.nn.Module:

999 return self.model

1000

1001 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1001 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1002 image_input = self._parse_and_validate_image_input(**kwargs)

1003 if image_input is None:

1004 return []

@@ -1006,7 +1006,7 @@ class ChameleonForConditionalGeneration(

1006 image_tokens = self.model.get_image_tokens(

1007 image_input["data"].to(self.config.dtype)

1008 )

1009 - vision_embeddings = self.model.get_input_embeddings(image_tokens)

1009 + vision_embeddings = self.model.embed_input_ids(image_tokens)

1010 return vision_embeddings

1011

1012 def forward(

vllm/model_executor/models/chatglm.py

+4 -4

@@ -353,7 +353,7 @@ class ChatGLMModel(nn.Module, SupportsQuant):

353 self.encoder.make_empty_intermediate_tensors

354 )

355

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

356 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

357 return self.embedding(input_ids)

358

359 def forward(

@@ -368,7 +368,7 @@ class ChatGLMModel(nn.Module, SupportsQuant):

368 if inputs_embeds is not None:

369 hidden_states = inputs_embeds

370 else:

371 - hidden_states = self.get_input_embeddings(input_ids)

371 + hidden_states = self.embed_input_ids(input_ids)

372 else:

373 assert intermediate_tensors is not None

374 hidden_states = intermediate_tensors["hidden_states"]

@@ -451,8 +451,8 @@ class ChatGLMBaseModel(nn.Module):

451 self.transformer.make_empty_intermediate_tensors

452 )

453

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

455 - return self.transformer.get_input_embeddings(input_ids)

454 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

455 + return self.transformer.embed_input_ids(input_ids)

456

457 def compute_logits(

458 self,

vllm/model_executor/models/clip.py

+6 -6

@@ -561,7 +561,7 @@ class CLIPTextTransformer(nn.Module):

561 eps=config.layer_norm_eps,

562 )

563

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

564 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

565 return self.embeddings.token_embedding(input_ids)

566

567 def forward(

@@ -842,7 +842,7 @@ class CLIPEmbeddingModel(nn.Module, SupportsMultiModal, SupportsQuant):

842 }

843 )

844

845 - # Assumes that self.forward is called after self.get_input_embeddings

845 + # Assumes that self.forward is called after self.embed_input_ids

846 self._is_text_input = True

847

848 def get_text_features(

@@ -903,7 +903,7 @@ class CLIPEmbeddingModel(nn.Module, SupportsMultiModal, SupportsQuant):

903 def get_language_model(self) -> torch.nn.Module:

904 return self.text_model

905

906 - def get_input_embeddings(

906 + def embed_input_ids(

907 self,

908 input_ids: torch.Tensor,

909 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -917,16 +917,16 @@ class CLIPEmbeddingModel(nn.Module, SupportsMultiModal, SupportsQuant):

917

918 # This is to satisfy the type checker for each overload

919 if multimodal_embeddings is None or is_multimodal is None:

920 - return super().get_input_embeddings(input_ids)

920 + return super().embed_input_ids(input_ids)

921

922 - return super().get_input_embeddings(

922 + return super().embed_input_ids(

923 input_ids,

924 multimodal_embeddings=multimodal_embeddings,

925 is_multimodal=is_multimodal,

926 handle_oov_mm_token=handle_oov_mm_token,

927 )

928

929 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

929 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

930 image_input = self._parse_and_validate_image_input(**kwargs)

931 if image_input is None:

932 return []

vllm/model_executor/models/cohere2_vision.py

+1 -1

@@ -439,7 +439,7 @@ class Cohere2VisionForConditionalGeneration(nn.Module, SupportsMultiModal, Suppo

439 def get_language_model(self) -> torch.nn.Module:

440 return self.language_model

441

442 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

442 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

443 image_input = self._parse_and_validate_image_input(**kwargs)

444 if image_input is None:

445 return []

vllm/model_executor/models/commandr.py

+4 -4

@@ -311,7 +311,7 @@ class CohereModel(nn.Module):

311 ["hidden_states", "residual"], config.hidden_size

312 )

313

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

314 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

315 return self.embed_tokens(input_ids)

316

317 def forward(

@@ -325,7 +325,7 @@ class CohereModel(nn.Module):

325 if inputs_embeds is not None:

326 hidden_states = inputs_embeds

327 else:

328 - hidden_states = self.get_input_embeddings(input_ids)

328 + hidden_states = self.embed_input_ids(input_ids)

329 residual = None

330 else:

331 assert intermediate_tensors is not None

@@ -436,8 +436,8 @@ class CohereForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsQuant):

436 self.model.make_empty_intermediate_tensors

437 )

438

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

440 - return self.model.get_input_embeddings(input_ids)

439 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

440 + return self.model.embed_input_ids(input_ids)

441

442 @torch.no_grad()

443 def forward(

vllm/model_executor/models/dbrx.py

+4 -4

@@ -354,7 +354,7 @@ class DbrxModel(nn.Module):

354 ["hidden_states"], config.d_model

355 )

356

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

357 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

358 return self.wte(input_ids)

359

360 def forward(

@@ -368,7 +368,7 @@ class DbrxModel(nn.Module):

368 if inputs_embeds is not None:

369 hidden_states = inputs_embeds

370 else:

371 - hidden_states = self.get_input_embeddings(input_ids)

371 + hidden_states = self.embed_input_ids(input_ids)

372 else:

373 assert intermediate_tensors

374 hidden_states = intermediate_tensors["hidden_states"]

@@ -455,8 +455,8 @@ class DbrxForCausalLM(nn.Module, SupportsPP):

455 self.transformer.make_empty_intermediate_tensors

456 )

457

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

459 - return self.transformer.get_input_embeddings(input_ids)

458 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

459 + return self.transformer.embed_input_ids(input_ids)

460

461 def forward(

462 self,

vllm/model_executor/models/deepseek_eagle.py

+3 -3

@@ -73,7 +73,7 @@ class DeepseekV2Model(nn.Module):

73 self.hnorm = RMSNorm(self.config.hidden_size, eps=self.config.rms_norm_eps)

74 self.norm = RMSNorm(self.config.hidden_size, eps=self.config.rms_norm_eps)

75

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

76 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

77 return self.embed_tokens(input_ids)

78

79 def forward(

@@ -222,8 +222,8 @@ class EagleDeepseekV3ForCausalLM(DeepseekV3ForCausalLM):

222 self.num_moe_layers = self.config.num_hidden_layers

223 self.set_moe_parameters()

224

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

226 - return self.model.get_input_embeddings(input_ids)

225 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

226 + return self.model.embed_input_ids(input_ids)

227

228 def forward(

229 self,

vllm/model_executor/models/deepseek_mtp.py

+3 -3

@@ -142,7 +142,7 @@ class DeepSeekMultiTokenPredictor(nn.Module):

142 )

143 self.logits_processor = LogitsProcessor(config.vocab_size)

144

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

145 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

146 return self.embed_tokens(input_ids)

147

148 def forward(

@@ -206,8 +206,8 @@ class DeepSeekMTP(nn.Module, SupportsPP, DeepseekV2MixtureOfExperts):

206 self.moe_layers.append(layer.mlp.experts)

207 self.extract_moe_parameters(example_moe)

208

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

210 - return self.model.get_input_embeddings(input_ids)

209 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

210 + return self.model.embed_input_ids(input_ids)

211

212 def forward(

213 self,

vllm/model_executor/models/deepseek_ocr.py

+1 -3

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

557 def get_language_model(self) -> torch.nn.Module:

558 return self.language_model

559

560 - def get_multimodal_embeddings(

561 - self, **kwargs: object

562 - ) -> MultiModalEmbeddings | None:

560 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

561 image_input = self._parse_and_validate_image_input(**kwargs)

562 if image_input is None:

563 return None

vllm/model_executor/models/deepseek_v2.py

+4 -4

@@ -1236,7 +1236,7 @@ class DeepseekV2Model(nn.Module):

1236 ["hidden_states", "residual"], config.hidden_size

1237 )

1238

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

1239 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

1240 return self.embed_tokens(input_ids)

1241

1242 def forward(

@@ -1250,7 +1250,7 @@ class DeepseekV2Model(nn.Module):

1250 if inputs_embeds is not None:

1251 hidden_states = inputs_embeds

1252 else:

1253 - hidden_states = self.get_input_embeddings(input_ids)

1253 + hidden_states = self.embed_input_ids(input_ids)

1254 residual = None

1255 else:

1256 assert intermediate_tensors is not None

@@ -1389,8 +1389,8 @@ class DeepseekV2ForCausalLM(

1389

1390 self.extract_moe_parameters(example_moe)

1391

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

1393 - return self.model.get_input_embeddings(input_ids)

1392 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

1393 + return self.model.embed_input_ids(input_ids)

1394

1395 def forward(

1396 self,

vllm/model_executor/models/deepseek_vl2.py

+1 -1

@@ -619,7 +619,7 @@ class DeepseekVLV2ForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

619 def get_language_model(self) -> torch.nn.Module:

620 return self.language_model

621

622 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

622 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

623 image_input = self._parse_and_validate_image_input(**kwargs)

624 if image_input is None:

625 return []

vllm/model_executor/models/dots1.py

+4 -4

@@ -398,7 +398,7 @@ class Dots1Model(nn.Module):

398 ["hidden_states", "residual"], config.hidden_size

399 )

400

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

401 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

402 return self.embed_tokens(input_ids)

403

404 def forward(

@@ -412,7 +412,7 @@ class Dots1Model(nn.Module):

412 if inputs_embeds is not None:

413 hidden_states = inputs_embeds

414 else:

415 - hidden_states = self.get_input_embeddings(input_ids)

415 + hidden_states = self.embed_input_ids(input_ids)

416 residual = None

417 else:

418 assert intermediate_tensors is not None

@@ -541,8 +541,8 @@ class Dots1ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

541 self.model.make_empty_intermediate_tensors

542 )

543

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

545 - return self.model.get_input_embeddings(input_ids)

544 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

545 + return self.model.embed_input_ids(input_ids)

546

547 def forward(

548 self,

vllm/model_executor/models/dots_ocr.py

+3 -3

@@ -840,7 +840,7 @@ class DotsOCRForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA

840 def get_language_model(self) -> torch.nn.Module:

841 return self.language_model

842

843 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

843 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

844 image_input = self._parse_and_validate_image_input(**kwargs)

845 if image_input is None:

846 return []

@@ -858,8 +858,8 @@ class DotsOCRForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA

858 if intermediate_tensors is not None:

859 inputs_embeds = None

860 elif inputs_embeds is None:

861 - vision_embeddings = self.get_multimodal_embeddings(**kwargs)

862 - inputs_embeds = self.get_input_embeddings(

861 + vision_embeddings = self.embed_multimodal(**kwargs)

862 + inputs_embeds = self.embed_input_ids(

863 input_ids,

864 vision_embeddings,

865 is_multimodal=input_ids == self.config.image_token_id,

vllm/model_executor/models/ernie45_moe.py

+4 -4

@@ -465,7 +465,7 @@ class Ernie4_5_MoeModel(nn.Module):

465 ["hidden_states", "residual"], config.hidden_size

466 )

467

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

468 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

469 return self.embed_tokens(input_ids)

470

471 def forward(

@@ -479,7 +479,7 @@ class Ernie4_5_MoeModel(nn.Module):

479 if inputs_embeds is not None:

480 hidden_states = inputs_embeds

481 else:

482 - hidden_states = self.get_input_embeddings(input_ids)

482 + hidden_states = self.embed_input_ids(input_ids)

483 residual = None

484 else:

485 assert intermediate_tensors is not None

@@ -726,8 +726,8 @@ class Ernie4_5_MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA, MixtureOfExpe

726 moe.n_redundant_experts = self.num_redundant_experts

727 moe.experts.update_expert_map()

728

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

730 - return self.model.get_input_embeddings(input_ids)

729 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

730 + return self.model.embed_input_ids(input_ids)

731

732 def forward(

733 self,

vllm/model_executor/models/ernie45_vl.py

+4 -6

@@ -1656,9 +1656,7 @@ class Ernie4_5_VLMoeForConditionalGeneration(

1656

1657 return modalities

1658

1659 - def get_multimodal_embeddings(

1660 - self, **kwargs: object

1661 - ) -> MultiModalEmbeddings | None:

1659 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

1660 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1661 if not modalities:

1662 return None

@@ -1681,7 +1679,7 @@ class Ernie4_5_VLMoeForConditionalGeneration(

1679

1680 return multimodal_embeddings

1681

1684 - def get_input_embeddings(

1682 + def embed_input_ids(

1683 self,

1684 input_ids: torch.Tensor,

1685 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1694,9 +1692,9 @@ class Ernie4_5_VLMoeForConditionalGeneration(

1692

1693 # This is to satisfy the type checker for each overload

1694 if multimodal_embeddings is None or is_multimodal is None:

1697 - return super().get_input_embeddings(input_ids)

1695 + return super().embed_input_ids(input_ids)

1696

1699 - return super().get_input_embeddings(

1697 + return super().embed_input_ids(

1698 input_ids,

1699 multimodal_embeddings=multimodal_embeddings,

1700 is_multimodal=is_multimodal,

vllm/model_executor/models/ernie45_vl_moe.py

+4 -4

@@ -561,7 +561,7 @@ class Ernie4_5_VLMoeModel(nn.Module):

561 ["hidden_states", "residual"], config.hidden_size

562 )

563

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

564 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

565 return self.embed_tokens(input_ids)

566

567 def forward(

@@ -577,7 +577,7 @@ class Ernie4_5_VLMoeModel(nn.Module):

577 if inputs_embeds is not None:

578 hidden_states = inputs_embeds

579 else:

580 - hidden_states = self.get_input_embeddings(input_ids)

580 + hidden_states = self.embed_input_ids(input_ids)

581 residual = None

582 else:

583 assert intermediate_tensors is not None

@@ -642,8 +642,8 @@ class Ernie4_5_VLMoeForCausalLM(nn.Module, SupportsPP):

642 self.model.make_empty_intermediate_tensors

643 )

644

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

646 - return self.model.get_input_embeddings(input_ids)

645 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

646 + return self.model.embed_input_ids(input_ids)

647

648 def forward(

649 self,

vllm/model_executor/models/ernie_mtp.py

+3 -3

@@ -112,7 +112,7 @@ class ErnieMultiTokenPredictor(nn.Module):

112 )

113 self.logits_processor = LogitsProcessor(config.vocab_size)

114

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

115 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

116 return self.embed_tokens(input_ids)

117

118 def forward(

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

160 if self.config.tie_word_embeddings:

161 self.lm_head.weight = self.model.embed_tokens.weight

162

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

164 - return self.model.get_input_embeddings(input_ids)

163 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

164 + return self.model.embed_input_ids(input_ids)

165

166 def forward(

167 self,

vllm/model_executor/models/exaone.py

+4 -4

@@ -357,7 +357,7 @@ class ExaoneModel(nn.Module):

357 ["hidden_states", "residual"], config.hidden_size

358 )

359

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

360 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

361 return self.wte(input_ids)

362

363 def forward(

@@ -371,7 +371,7 @@ class ExaoneModel(nn.Module):

371 if inputs_embeds is not None:

372 hidden_states = inputs_embeds

373 else:

374 - hidden_states = self.get_input_embeddings(input_ids)

374 + hidden_states = self.embed_input_ids(input_ids)

375 residual = None

376 else:

377 assert intermediate_tensors is not None

@@ -512,8 +512,8 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

512 self.transformer.make_empty_intermediate_tensors

513 )

514

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

516 - return self.model.get_input_embeddings(input_ids)

515 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

516 + return self.model.embed_input_ids(input_ids)

517

518 def forward(

519 self,

vllm/model_executor/models/exaone4.py

+4 -4

@@ -344,7 +344,7 @@ class Exaone4Model(nn.Module):

344 ["hidden_states", "residual"], config.hidden_size

345 )

346

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

347 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

348 return self.embed_tokens(input_ids)

349

350 def forward(

@@ -358,7 +358,7 @@ class Exaone4Model(nn.Module):

358 if inputs_embeds is not None:

359 hidden_states = inputs_embeds

360 else:

361 - hidden_states = self.get_input_embeddings(input_ids)

361 + hidden_states = self.embed_input_ids(input_ids)

362 residual = None

363 else:

364 assert intermediate_tensors is not None

@@ -498,8 +498,8 @@ class Exaone4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

498 self.model.make_empty_intermediate_tensors

499 )

500

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

502 - return self.model.get_input_embeddings(input_ids)

501 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

502 + return self.model.embed_input_ids(input_ids)

503

504 def forward(

505 self,

vllm/model_executor/models/falcon.py

+4 -4

@@ -399,7 +399,7 @@ class FalconModel(nn.Module):

399 ["hidden_states"], config.hidden_size

400 )

401

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

402 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

403 return self.word_embeddings(input_ids)

404

405 def forward(

@@ -413,7 +413,7 @@ class FalconModel(nn.Module):

413 if inputs_embeds is not None:

414 hidden_states = inputs_embeds

415 else:

416 - hidden_states = self.get_input_embeddings(input_ids)

416 + hidden_states = self.embed_input_ids(input_ids)

417 else:

418 hidden_states = intermediate_tensors["hidden_states"]

419 for layer in islice(self.h, self.start_layer, self.end_layer):

@@ -515,8 +515,8 @@ class FalconForCausalLM(nn.Module, SupportsPP):

515 self.transformer.make_empty_intermediate_tensors

516 )

517

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

519 - return self.transformer.get_input_embeddings(input_ids)

518 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

519 + return self.transformer.embed_input_ids(input_ids)

520

521 def forward(

522 self,

vllm/model_executor/models/falcon_h1.py

+4 -4

@@ -461,7 +461,7 @@ class FalconH1Model(nn.Module):

461 else:

462 self.final_layernorm = PPMissingLayer()

463

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

464 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

465 return self.embed_tokens(input_ids)

466

467 def forward(

@@ -476,7 +476,7 @@ class FalconH1Model(nn.Module):

476 hidden_states = inputs_embeds * self.embedding_multiplier

477 else:

478 hidden_states = (

479 - self.get_input_embeddings(input_ids) * self.embedding_multiplier

479 + self.embed_input_ids(input_ids) * self.embedding_multiplier

480 )

481 else:

482 assert intermediate_tensors is not None

@@ -601,8 +601,8 @@ class FalconH1ForCausalLM(

601 self.model.make_empty_intermediate_tensors

602 )

603

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

605 - return self.model.get_input_embeddings(input_ids)

604 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

605 + return self.model.embed_input_ids(input_ids)

606

607 def forward(

608 self,

vllm/model_executor/models/fuyu.py

+1 -1

@@ -333,7 +333,7 @@ class FuyuForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

333 def get_language_model(self) -> torch.nn.Module:

334 return self.language_model

335

336 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

336 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

337 image_input = self._parse_and_validate_image_input(**kwargs)

338 if image_input is None:

339 return []

vllm/model_executor/models/gemma.py

+4 -4

@@ -293,7 +293,7 @@ class GemmaModel(nn.Module):

293 ["hidden_states", "residual"], config.hidden_size

294 )

295

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

296 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

297 return self.embed_tokens(input_ids)

298

299 def forward(

@@ -307,7 +307,7 @@ class GemmaModel(nn.Module):

307 if inputs_embeds is not None:

308 hidden_states = inputs_embeds

309 else:

310 - hidden_states = self.get_input_embeddings(input_ids)

310 + hidden_states = self.embed_input_ids(input_ids)

311 hidden_states *= self.normalizer

312 residual = None

313 else:

@@ -396,8 +396,8 @@ class GemmaForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

396 self.model.make_empty_intermediate_tensors

397 )

398

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

400 - return self.model.get_input_embeddings(input_ids)

399 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

400 + return self.model.embed_input_ids(input_ids)

401

402 def forward(

403 self,

vllm/model_executor/models/gemma2.py

+4 -4

@@ -290,7 +290,7 @@ class Gemma2Model(nn.Module):

290 ["hidden_states", "residual"], config.hidden_size

291 )

292

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

293 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

294 return self.embed_tokens(input_ids)

295

296 def forward(

@@ -304,7 +304,7 @@ class Gemma2Model(nn.Module):

304 if inputs_embeds is not None:

305 hidden_states = inputs_embeds

306 else:

307 - hidden_states = self.get_input_embeddings(input_ids)

307 + hidden_states = self.embed_input_ids(input_ids)

308 hidden_states *= self.normalizer

309 residual = None

310 else:

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

409 self.model.make_empty_intermediate_tensors

410 )

411

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

413 - return self.model.get_input_embeddings(input_ids)

412 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

413 + return self.model.embed_input_ids(input_ids)

414

415 def forward(

416 self,

vllm/model_executor/models/gemma3.py

+4 -4

@@ -393,7 +393,7 @@ class Gemma3Model(nn.Module):

393 ["hidden_states", "residual"], config.hidden_size

394 )

395

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

396 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

397 # NOTE(woosuk): Only apply the normalizer to the output of

398 # vocab embedding. Don't apply it to the vision embedding.

399 return self.embed_tokens(input_ids) * self.normalizer

@@ -410,7 +410,7 @@ class Gemma3Model(nn.Module):

410 if inputs_embeds is not None:

411 hidden_states = inputs_embeds

412 else:

413 - hidden_states = self.get_input_embeddings(input_ids)

413 + hidden_states = self.embed_input_ids(input_ids)

414 residual = None

415 else:

416 assert intermediate_tensors is not None

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

540 self.model.make_empty_intermediate_tensors

541 )

542

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

544 - return self.model.get_input_embeddings(input_ids)

543 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

544 + return self.model.embed_input_ids(input_ids)

545

546 def forward(

547 self,

vllm/model_executor/models/gemma3_mm.py

+1 -1

@@ -596,7 +596,7 @@ class Gemma3ForConditionalGeneration(

596 def get_language_model(self) -> torch.nn.Module:

597 return self.language_model

598

599 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

599 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

600 image_input = self._parse_and_validate_image_input(**kwargs)

601 if image_input is None:

602 return []

vllm/model_executor/models/gemma3n.py

+6 -6

@@ -685,7 +685,7 @@ class Gemma3nSelfDecoder(nn.Module):

685 per_layer_inputs = per_layer_projection

686 return per_layer_inputs

687

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

688 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

689 return self.embed_tokens(input_ids) * self.embed_scale

690

691 def altup_embed(self, hidden_states_0: torch.Tensor) -> torch.Tensor:

@@ -712,7 +712,7 @@ class Gemma3nSelfDecoder(nn.Module):

712 if inputs_embeds is not None:

713 hidden_states_0 = inputs_embeds

714 else:

715 - hidden_states_0 = self.get_input_embeddings(input_ids)

715 + hidden_states_0 = self.embed_input_ids(input_ids)

716

717 adjusted_per_layer_inputs = self.get_per_layer_inputs(

718 hidden_states_0, per_layer_inputs

@@ -881,8 +881,8 @@ class Gemma3nTextModel(nn.Module, SupportsQuant):

881 def get_per_layer_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:

882 return self.self_decoder.get_per_layer_input_embeddings(input_ids)

883

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

885 - return self.self_decoder.get_input_embeddings(input_ids)

884 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

885 + return self.self_decoder.embed_input_ids(input_ids)

886

887 def fast_prefill_forward(

888 self,

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

1125 config.vocab_size, soft_cap=config.final_logit_softcapping

1126 )

1127

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

1129 - return self.model.get_input_embeddings(input_ids)

1128 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

1129 + return self.model.embed_input_ids(input_ids)

1130

1131 def forward(

1132 self,

vllm/model_executor/models/gemma3n_mm.py

+6 -6

@@ -645,7 +645,7 @@ class Gemma3nForConditionalGeneration(

645 def get_language_model(self) -> torch.nn.Module:

646 return self.language_model

647

648 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

648 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

649 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

650 if mm_input_by_modality is None:

651 return []

@@ -664,7 +664,7 @@ class Gemma3nForConditionalGeneration(

664 multimodal_embeddings.extend(audio_embeddings)

665 return multimodal_embeddings

666

667 - def get_input_embeddings(

667 + def embed_input_ids(

668 self,

669 input_ids: torch.Tensor,

670 multimodal_embeddings: Optional[MultiModalEmbeddings] = None,

@@ -689,9 +689,9 @@ class Gemma3nForConditionalGeneration(

689

690 # This is to satisfy the type checker for each overload

691 if multimodal_embeddings is None or is_multimodal is None:

692 - return super().get_input_embeddings(input_ids)

692 + return super().embed_input_ids(input_ids)

693

694 - return super().get_input_embeddings(

694 + return super().embed_input_ids(

695 input_ids,

696 multimodal_embeddings=multimodal_embeddings,

697 is_multimodal=is_multimodal,

@@ -709,10 +709,10 @@ class Gemma3nForConditionalGeneration(

709 if intermediate_tensors is not None:

710 inputs_embeds = None

711

712 - # NOTE (NickLucche) During profiling, `get_input_embeddings` is not

712 + # NOTE (NickLucche) During profiling, `embed_input_ids` is not

713 # called, hence we don't have input_ids to compute PLEs. We simply

714 # select a chunk of pre-allocated PLEs. During normal execution,

715 - # `get_input_embeddings` is called before forward, hence this slice

715 + # `embed_input_ids` is called before forward, hence this slice

716 # will contain PLEs computed from the actual input_ids.

717 per_layer_inputs = self.per_layer_embeddings[: inputs_embeds.shape[0]]

718

vllm/model_executor/models/glm4.py

+2 -2

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

275 self.model.make_empty_intermediate_tensors

276 )

277

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

279 - return self.model.get_input_embeddings(input_ids)

278 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

279 + return self.model.embed_input_ids(input_ids)

280

281 def forward(

282 self,

vllm/model_executor/models/glm4_1v.py

+1 -3

@@ -1594,9 +1594,7 @@ class Glm4vForConditionalGeneration(

1594 def get_language_model(self) -> torch.nn.Module:

1595 return self.language_model

1596

1597 - def get_multimodal_embeddings(

1598 - self, **kwargs: object

1599 - ) -> MultiModalEmbeddings | None:

1597 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

1598 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

1599 if not mm_input_by_modality:

1600 return None

vllm/model_executor/models/glm4_moe.py

+4 -4

@@ -455,7 +455,7 @@ class Glm4MoeModel(nn.Module):

455 ["hidden_states", "residual"], config.hidden_size

456 )

457

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

458 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

459 return self.embed_tokens(input_ids)

460

461 def forward(

@@ -469,7 +469,7 @@ class Glm4MoeModel(nn.Module):

469 if inputs_embeds is not None:

470 hidden_states = inputs_embeds

471 else:

472 - hidden_states = self.get_input_embeddings(input_ids)

472 + hidden_states = self.embed_input_ids(input_ids)

473 residual = None

474 else:

475 assert intermediate_tensors is not None

@@ -704,8 +704,8 @@ class Glm4MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA, Glm4MixtureOfExper

704

705 self.extract_moe_parameters(example_moe)

706

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

708 - return self.model.get_input_embeddings(input_ids)

707 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

708 + return self.model.embed_input_ids(input_ids)

709

710 def forward(

711 self,

vllm/model_executor/models/glm4_moe_mtp.py

+3 -3

@@ -149,7 +149,7 @@ class Glm4MoeMultiTokenPredictor(nn.Module):

149 )

150 self.logits_processor = LogitsProcessor(config.vocab_size)

151

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

152 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

153 return self.embed_tokens(input_ids)

154

155 def forward(

@@ -211,8 +211,8 @@ class Glm4MoeMTP(nn.Module, SupportsPP, Glm4MixtureOfExperts):

211 self.moe_layers.append(layer.mlp.experts)

212 self.extract_moe_parameters(example_moe)

213

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

215 - return self.model.get_input_embeddings(input_ids)

214 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

215 + return self.model.embed_input_ids(input_ids)

216

217 def forward(

218 self,

vllm/model_executor/models/glm4v.py

+2 -2

@@ -756,9 +756,9 @@ class GLM4VForCausalLM(

756 def get_language_model(self) -> torch.nn.Module:

757 return self.transformer

758

759 - get_input_embeddings = SupportsMultiModal.get_input_embeddings

759 + embed_input_ids = SupportsMultiModal.embed_input_ids

760

761 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

761 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

762 image_input = self._parse_and_validate_image_input(**kwargs)

763 if image_input is None:

764 return []

vllm/model_executor/models/gpt2.py

+6 -6

@@ -213,7 +213,7 @@ class GPT2Model(nn.Module):

213 ["hidden_states"], config.n_embd

214 )

215

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

216 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

217 return self.wte(input_ids)

218

219 def forward(

@@ -225,7 +225,7 @@ class GPT2Model(nn.Module):

225 ) -> torch.Tensor | IntermediateTensors:

226 if get_pp_group().is_first_rank:

227 if inputs_embeds is None:

228 - inputs_embeds = self.get_input_embeddings(input_ids)

228 + inputs_embeds = self.embed_input_ids(input_ids)

229 position_embeds = self.wpe(position_ids)

230 hidden_states = inputs_embeds + position_embeds

231 else:

@@ -293,8 +293,8 @@ class GPT2LMHeadModel(nn.Module, SupportsPP):

293 self.transformer.make_empty_intermediate_tensors

294 )

295

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

297 - return self.transformer.get_input_embeddings(input_ids)

296 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

297 + return self.transformer.embed_input_ids(input_ids)

298

299 def forward(

300 self,

@@ -365,8 +365,8 @@ class GPT2ForSequenceClassification(nn.Module, SupportsCrossEncoding):

365 }

366 )

367

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

369 - return self.transformer.get_input_embeddings(input_ids)

368 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

369 + return self.transformer.embed_input_ids(input_ids)

370

371 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):

372 loader = AutoWeightsLoader(self)

vllm/model_executor/models/gpt_bigcode.py

+4 -4

@@ -230,7 +230,7 @@ class GPTBigCodeModel(nn.Module):

230 ["hidden_states"], config.n_embd

231 )

232

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

233 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

234 return self.wte(input_ids)

235

236 def forward(

@@ -242,7 +242,7 @@ class GPTBigCodeModel(nn.Module):

242 ) -> torch.Tensor | IntermediateTensors:

243 if get_pp_group().is_first_rank:

244 if inputs_embeds is None:

245 - inputs_embeds = self.get_input_embeddings(input_ids)

245 + inputs_embeds = self.embed_input_ids(input_ids)

246 hidden_states = inputs_embeds + self.wpe(position_ids)

247 else:

248 hidden_states = intermediate_tensors["hidden_states"]

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

306 self.transformer.make_empty_intermediate_tensors

307 )

308

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

310 - return self.transformer.get_input_embeddings(input_ids)

309 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

310 + return self.transformer.embed_input_ids(input_ids)

311

312 def forward(

313 self,

vllm/model_executor/models/gpt_j.py

+4 -4

@@ -215,7 +215,7 @@ class GPTJModel(nn.Module):

215 ["hidden_states"], config.n_embd

216 )

217

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

218 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

219 return self.wte(input_ids)

220

221 def forward(

@@ -229,7 +229,7 @@ class GPTJModel(nn.Module):

229 if inputs_embeds is not None:

230 hidden_states = inputs_embeds

231 else:

232 - hidden_states = self.get_input_embeddings(input_ids)

232 + hidden_states = self.embed_input_ids(input_ids)

233 else:

234 hidden_states = intermediate_tensors["hidden_states"]

235 for layer in islice(self.h, self.start_layer, self.end_layer):

@@ -319,8 +319,8 @@ class GPTJForCausalLM(nn.Module, SupportsPP):

319 self.transformer.make_empty_intermediate_tensors

320 )

321

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

323 - return self.transformer.get_input_embeddings(input_ids)

322 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

323 + return self.transformer.embed_input_ids(input_ids)

324

325 def forward(

326 self,

vllm/model_executor/models/gpt_neox.py

+4 -4

@@ -229,7 +229,7 @@ class GPTNeoXModel(nn.Module):

229 ["hidden_states"], config.hidden_size

230 )

231

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

232 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

233 return self.embed_in(input_ids)

234

235 def forward(

@@ -243,7 +243,7 @@ class GPTNeoXModel(nn.Module):

243 if inputs_embeds is not None:

244 hidden_states = inputs_embeds

245 else:

246 - hidden_states = self.get_input_embeddings(input_ids)

246 + hidden_states = self.embed_input_ids(input_ids)

247 else:

248 hidden_states = intermediate_tensors["hidden_states"]

249 for layer in islice(self.layers, self.start_layer, self.end_layer):

@@ -317,8 +317,8 @@ class GPTNeoXForCausalLM(nn.Module, SupportsPP):

317 self.gpt_neox.make_empty_intermediate_tensors

318 )

319

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

321 - return self.gpt_neox.get_input_embeddings(input_ids)

320 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

321 + return self.gpt_neox.embed_input_ids(input_ids)

322

323 def forward(

324 self,

vllm/model_executor/models/gpt_oss.py

+4 -4

@@ -269,7 +269,7 @@ class GptOssModel(nn.Module):

269 )

270 self.aux_hidden_state_layers = tuple[int, ...]()

271

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

272 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

273 return self.embedding(input_ids)

274

275 def forward(

@@ -283,7 +283,7 @@ class GptOssModel(nn.Module):

283 if inputs_embeds is not None:

284 x = inputs_embeds

285 else:

286 - x = self.get_input_embeddings(input_ids)

286 + x = self.embed_input_ids(input_ids)

287

288 residual = None

289 else:

@@ -703,8 +703,8 @@ class GptOssForCausalLM(nn.Module, SupportsPP, SupportsEagle3, SupportsLoRA):

703 num_layers = len(self.model.layers)

704 return (2, num_layers // 2, num_layers - 3)

705

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

707 - return self.model.get_input_embeddings(input_ids)

706 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

707 + return self.model.embed_input_ids(input_ids)

708

709 def forward(

710 self,

vllm/model_executor/models/granite.py

+4 -4

@@ -318,7 +318,7 @@ class GraniteModel(nn.Module):

318 else:

319 self.norm = PPMissingLayer()

320

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

321 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

322 return self.embed_tokens(input_ids)

323

324 def forward(

@@ -332,7 +332,7 @@ class GraniteModel(nn.Module):

332 if inputs_embeds is not None:

333 hidden_states = inputs_embeds

334 else:

335 - hidden_states = self.get_input_embeddings(input_ids)

335 + hidden_states = self.embed_input_ids(input_ids)

336

337 hidden_states *= self.config.embedding_multiplier

338 else:

@@ -473,8 +473,8 @@ class GraniteForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

473 else:

474 self.lm_head = PPMissingLayer()

475

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

477 - return self.model.get_input_embeddings(input_ids)

476 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

477 + return self.model.embed_input_ids(input_ids)

478

479 def forward(

480 self,

vllm/model_executor/models/granite_speech.py

+4 -4

@@ -767,7 +767,7 @@ class GraniteSpeechForConditionalGeneration(

767 def get_language_model(self) -> torch.nn.Module:

768 return self.language_model

769

770 - def get_multimodal_embeddings(

770 + def embed_multimodal(

771 self,

772 **kwargs: object,

773 ) -> MultiModalEmbeddings:

@@ -779,7 +779,7 @@ class GraniteSpeechForConditionalGeneration(

779 audio_features = self._process_audio_input(audio_input)

780 return audio_features

781

782 - def get_input_embeddings(

782 + def embed_input_ids(

783 self,

784 input_ids: torch.Tensor,

785 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -790,9 +790,9 @@ class GraniteSpeechForConditionalGeneration(

790 ) -> torch.Tensor:

791 # This is to satisfy the type checker for each overload

792 if multimodal_embeddings is None or is_multimodal is None:

793 - return super().get_input_embeddings(input_ids)

793 + return super().embed_input_ids(input_ids)

794

795 - return super().get_input_embeddings(

795 + return super().embed_input_ids(

796 input_ids,

797 multimodal_embeddings=multimodal_embeddings,

798 is_multimodal=is_multimodal,

vllm/model_executor/models/granitemoe.py

+4 -4

@@ -315,7 +315,7 @@ class GraniteMoeModel(nn.Module):

315

316 self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

317

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

318 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

319 return self.embed_tokens(input_ids)

320

321 def forward(

@@ -329,7 +329,7 @@ class GraniteMoeModel(nn.Module):

329 if inputs_embeds is not None:

330 hidden_states = inputs_embeds

331 else:

332 - hidden_states = self.get_input_embeddings(input_ids)

332 + hidden_states = self.embed_input_ids(input_ids)

333 hidden_states *= self.embedding_multiplier

334 else:

335 assert intermediate_tensors is not None

@@ -531,8 +531,8 @@ class GraniteMoeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

531 scale=1 / self.config.logits_scaling,

532 )

533

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

535 - return self.model.get_input_embeddings(input_ids)

534 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

535 + return self.model.embed_input_ids(input_ids)

536

537 def forward(

538 self,

vllm/model_executor/models/granitemoehybrid.py

+4 -4

@@ -366,7 +366,7 @@ class GraniteMoeHybridModel(nn.Module):

366

367 self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

368

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

369 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

370 return self.embed_tokens(input_ids)

371

372 def forward(

@@ -380,7 +380,7 @@ class GraniteMoeHybridModel(nn.Module):

380 if inputs_embeds is not None:

381 hidden_states = inputs_embeds

382 else:

383 - hidden_states = self.get_input_embeddings(input_ids)

383 + hidden_states = self.embed_input_ids(input_ids)

384 hidden_states = hidden_states * self.embedding_multiplier

385 residual = None

386 else:

@@ -680,8 +680,8 @@ class GraniteMoeHybridForCausalLM(

680 self.model.make_empty_intermediate_tensors

681 )

682

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

684 - return self.model.get_input_embeddings(input_ids)

683 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

684 + return self.model.embed_input_ids(input_ids)

685

686 def forward(

687 self,

vllm/model_executor/models/granitemoeshared.py

+4 -4

@@ -182,7 +182,7 @@ class GraniteMoeSharedModel(nn.Module):

182

183 self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

184

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

185 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

186 return self.embed_tokens(input_ids)

187

188 def forward(

@@ -196,7 +196,7 @@ class GraniteMoeSharedModel(nn.Module):

196 if inputs_embeds is not None:

197 hidden_states = inputs_embeds

198 else:

199 - hidden_states = self.get_input_embeddings(input_ids)

199 + hidden_states = self.embed_input_ids(input_ids)

200 hidden_states *= self.embedding_multiplier

201 else:

202 assert intermediate_tensors is not None

@@ -295,8 +295,8 @@ class GraniteMoeSharedForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

295 scale=1 / self.config.logits_scaling,

296 )

297

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

299 - return self.model.get_input_embeddings(input_ids)

298 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

299 + return self.model.embed_input_ids(input_ids)

300

301 def forward(

302 self,

vllm/model_executor/models/grok1.py

+4 -4

@@ -334,7 +334,7 @@ class Grok1Model(nn.Module):

334 ["hidden_states", "residual"], config.hidden_size

335 )

336

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

337 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

338 hidden_states = self.embed_tokens(input_ids)

339 hidden_states = hidden_states * self.embedding_multiplier_scale

340 return hidden_states

@@ -350,7 +350,7 @@ class Grok1Model(nn.Module):

350 if inputs_embeds is not None:

351 hidden_states = inputs_embeds

352 else:

353 - hidden_states = self.get_input_embeddings(input_ids)

353 + hidden_states = self.embed_input_ids(input_ids)

354 residual = None

355 else:

356 assert intermediate_tensors is not None

@@ -522,8 +522,8 @@ class Grok1ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

522 self.model.make_empty_intermediate_tensors

523 )

524

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

526 - return self.model.get_input_embeddings(input_ids)

525 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

526 + return self.model.embed_input_ids(input_ids)

527

528 def forward(

529 self,

vllm/model_executor/models/hunyuan_v1.py

+4 -4

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

643 else:

644 self.norm = PPMissingLayer()

645

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

646 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

647 return self.embed_tokens(input_ids)

648

649 def forward(

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

657 if inputs_embeds is not None:

658 hidden_states = inputs_embeds

659 else:

660 - hidden_states = self.get_input_embeddings(input_ids)

660 + hidden_states = self.embed_input_ids(input_ids)

661 residual = None

662 else:

663 assert intermediate_tensors is not None

@@ -987,8 +987,8 @@ class HunyuanV1ModelBase(nn.Module, SupportsLoRA, SupportsPP):

987 )

988 return loader.load_weights(weights)

989

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

991 - return self.model.get_input_embeddings(input_ids)

990 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

991 + return self.model.embed_input_ids(input_ids)

992

993

994 class HunYuanMoEV1Base(HunyuanV1ModelBase, MixtureOfExperts):

vllm/model_executor/models/hyperclovax_vision.py

+1 -1

@@ -732,7 +732,7 @@ class HCXVisionForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

732 def get_language_model(self) -> torch.nn.Module:

733 return self.language_model

734

735 - def get_multimodal_embeddings(

735 + def embed_multimodal(

736 self,

737 **kwargs: object,

738 ) -> MultiModalEmbeddings:

vllm/model_executor/models/idefics3.py

+3 -3

@@ -550,8 +550,8 @@ class Idefics3Model(nn.Module):

550

551 return image_hidden_states

552

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

554 - return self.text_model.get_input_embeddings(input_ids)

553 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

554 + return self.text_model.embed_input_ids(input_ids)

555

556 def forward(

557 self,

@@ -674,7 +674,7 @@ class Idefics3ForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsLo

674 def get_language_model(self) -> torch.nn.Module:

675 return self.model

676

677 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

677 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

678 image_input = self._parse_and_validate_image_input(**kwargs)

679 if image_input is None:

680 return []

vllm/model_executor/models/interfaces.py

+19 -13

@@ -94,7 +94,7 @@ class SupportsMultiModal(Protocol):

94 """

95 ...

96

97 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

97 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

98 """

99 Returns multimodal embeddings generated from multimodal kwargs

100 to be merged with text embeddings.

@@ -104,7 +104,13 @@ class SupportsMultiModal(Protocol):

104 the appearances of their corresponding multimodal data item in the

105 input prompt.

106 """

107 - ...

107 + if hasattr(self, "get_multimodal_embeddings"):

108 + logger.warning_once(

109 + "`get_multimodal_embeddings` for vLLM models is deprecated and will be "

110 + "removed in v0.13.0 or v1.0.0, whichever is earlier. Please rename "

111 + "this method to `embed_multimodal`."

112 + )

113 + return self.get_multimodal_embeddings(**kwargs)

114

115 def get_language_model(self) -> VllmModel:

116 """

@@ -119,10 +125,10 @@ class SupportsMultiModal(Protocol):

125 ...

126

127 @overload

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

128 + def embed_input_ids(self, input_ids: Tensor) -> Tensor: ...

129

130 @overload

125 - def get_input_embeddings(

131 + def embed_input_ids(

132 self,

133 input_ids: Tensor,

134 multimodal_embeddings: MultiModalEmbeddings,

@@ -131,17 +137,17 @@ class SupportsMultiModal(Protocol):

137 handle_oov_mm_token: bool = False,

138 ) -> Tensor: ...

139

134 - def _get_text_embeddings(

140 + def _embed_text_input_ids(

141 self,

142 input_ids: Tensor,

137 - get_input_embeddings: Callable[[Tensor], Tensor],

143 + embed_input_ids: Callable[[Tensor], Tensor],

144 *,

145 is_multimodal: Tensor | None,

146 handle_oov_mm_token: bool,

147 ) -> Tensor:

148 if handle_oov_mm_token and is_multimodal is not None:

149 is_text = ~is_multimodal

144 - text_embeds = get_input_embeddings(input_ids[is_text])

150 + text_embeds = embed_input_ids(input_ids[is_text])

151

152 return torch.empty(

153 (input_ids.shape[0], text_embeds.shape[1]),

@@ -149,9 +155,9 @@ class SupportsMultiModal(Protocol):

155 device=text_embeds.device,

156 ).masked_scatter_(is_text.unsqueeze_(-1), text_embeds)

157

152 - return get_input_embeddings(input_ids)

158 + return embed_input_ids(input_ids)

159

154 - def get_input_embeddings(

160 + def embed_input_ids(

161 self,

162 input_ids: Tensor,

163 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -167,15 +173,15 @@ class SupportsMultiModal(Protocol):

173

174 In case the multi-modal token IDs exceed the vocabulary size of

175 the language model, you can set `handle_oov_mm_token=False`

170 - to avoid calling the language model's `get_input_embeddings` method

176 + to avoid calling the language model's `embed_input_ids` method

177 on those tokens. Note however that doing so increases memory usage

178 as an additional buffer is needed to hold the input embeddings.

179 """

180 from .utils import _merge_multimodal_embeddings

181

176 - inputs_embeds = self._get_text_embeddings(

182 + inputs_embeds = self._embed_text_input_ids(

183 input_ids,

178 - self.get_language_model().get_input_embeddings,

184 + self.get_language_model().embed_input_ids,

185 is_multimodal=is_multimodal,

186 handle_oov_mm_token=handle_oov_mm_token,

187 )

@@ -185,7 +191,7 @@ class SupportsMultiModal(Protocol):

191

192 if is_multimodal is None:

193 raise ValueError(

188 - "`get_input_embeddings` now requires `is_multimodal` arg, "

194 + "`embed_input_ids` now requires `is_multimodal` arg, "

195 "please update your model runner according to "

196 "https://github.com/vllm-project/vllm/pull/16229."

197 )

vllm/model_executor/models/interfaces_base.py

+23 -20

@@ -41,24 +41,19 @@ T_co = TypeVar("T_co", default=torch.Tensor, covariant=True)

41 class VllmModel(Protocol[T_co]):

42 """The interface required for all models in vLLM."""

43

44 - def __init__(

45 - self,

46 - vllm_config: VllmConfig,

47 - prefix: str = "",

48 - ) -> None: ...

44 + def __init__(self, vllm_config: VllmConfig, prefix: str = "") -> None: ...

45

50 - def get_input_embeddings(

51 - self,

52 - input_ids: torch.Tensor,

53 - ) -> torch.Tensor:

46 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

47 """Apply token embeddings to `input_ids`."""

55 - ...

48 + if hasattr(self, "get_input_embeddings"):

49 + logger.warning_once(

50 + "`get_input_embeddings` for vLLM models is deprecated and will be "

51 + "removed in v0.13.0 or v1.0.0, whichever is earlier. Please rename "

52 + "this method to `embed_input_ids`."

53 + )

54 + return self.get_input_embeddings(input_ids)

55

57 - def forward(

58 - self,

59 - input_ids: torch.Tensor,

60 - positions: torch.Tensor,

61 - ) -> T_co: ...

56 + def forward(self, input_ids: torch.Tensor, positions: torch.Tensor) -> T_co: ...

57

58

59 def _check_vllm_model_init(model: type[object] | object) -> bool:

@@ -66,11 +61,19 @@ def _check_vllm_model_init(model: type[object] | object) -> bool:

61 return supports_kw(model_init, "vllm_config")

62

63

69 -def _check_vllm_model_get_input_embeddings(model: type[object] | object) -> bool:

70 - model_get_input_embeddings = getattr(model, "get_input_embeddings", None)

71 - if not callable(model_get_input_embeddings):

64 +def _check_vllm_model_embed_input_ids(model: type[object] | object) -> bool:

65 + model_embed_input_ids = getattr(model, "embed_input_ids", None)

66 + if not callable(model_embed_input_ids):

67 + model_get_input_embeddings = getattr(model, "get_input_embeddings", None)

68 + if callable(model_get_input_embeddings):

69 + logger.warning(

70 + "`get_input_embeddings` for vLLM models is deprecated and will be "

71 + "removed in v0.13.0 or v1.0.0, whichever is earlier. Please rename "

72 + "this method to `embed_input_ids`."

73 + )

74 + model.embed_input_ids = model_get_input_embeddings

75 logger.warning(

73 - "The model (%s) is missing the `get_input_embeddings` method.",

76 + "The model (%s) is missing the `embed_input_ids` method.",

77 model,

78 )

79 return False

@@ -110,7 +113,7 @@ def is_vllm_model(

113 ) -> TypeIs[type[VllmModel]] | TypeIs[VllmModel]:

114 return (

115 _check_vllm_model_init(model)

113 - and _check_vllm_model_get_input_embeddings(model)

116 + and _check_vllm_model_embed_input_ids(model)

117 and _check_vllm_model_forward(model)

118 )

119

vllm/model_executor/models/internlm2.py

+4 -4

@@ -284,7 +284,7 @@ class InternLM2Model(nn.Module):

284 ["hidden_states", "residual"], config.hidden_size

285 )

286

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

287 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

288 return self.tok_embeddings(input_ids)

289

290 def forward(

@@ -298,7 +298,7 @@ class InternLM2Model(nn.Module):

298 if inputs_embeds is not None:

299 hidden_states = inputs_embeds

300 else:

301 - hidden_states = self.get_input_embeddings(input_ids)

301 + hidden_states = self.embed_input_ids(input_ids)

302 residual = None

303 else:

304 assert intermediate_tensors is not None

@@ -350,8 +350,8 @@ class InternLM2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

350 self.model.make_empty_intermediate_tensors

351 )

352

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

354 - return self.model.get_input_embeddings(input_ids)

353 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

354 + return self.model.embed_input_ids(input_ids)

355

356 def forward(

357 self,

vllm/model_executor/models/interns1.py

+4 -4

@@ -742,7 +742,7 @@ class InternS1ForConditionalGeneration(

742 def get_language_model(self) -> torch.nn.Module:

743 return self.language_model

744

745 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

745 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

746 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

747 if not modalities:

748 return []

@@ -765,7 +765,7 @@ class InternS1ForConditionalGeneration(

765

766 return multimodal_embeddings

767

768 - def get_input_embeddings(

768 + def embed_input_ids(

769 self,

770 input_ids: torch.Tensor,

771 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -778,9 +778,9 @@ class InternS1ForConditionalGeneration(

778

779 # This is to satisfy the type checker for each overload

780 if multimodal_embeddings is None or is_multimodal is None:

781 - return super().get_input_embeddings(input_ids)

781 + return super().embed_input_ids(input_ids)

782

783 - return super().get_input_embeddings(

783 + return super().embed_input_ids(

784 input_ids,

785 multimodal_embeddings=multimodal_embeddings,

786 is_multimodal=is_multimodal,

vllm/model_executor/models/internvl.py

+4 -4

@@ -1344,7 +1344,7 @@ class InternVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA)

1344 def get_language_model(self) -> torch.nn.Module:

1345 return self.language_model

1346

1347 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1347 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1348 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1349 if not modalities:

1350 return []

@@ -1367,7 +1367,7 @@ class InternVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA)

1367

1368 return multimodal_embeddings

1369

1370 - def get_input_embeddings(

1370 + def embed_input_ids(

1371 self,

1372 input_ids: torch.Tensor,

1373 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1380,9 +1380,9 @@ class InternVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA)

1380

1381 # This is to satisfy the type checker for each overload

1382 if multimodal_embeddings is None or is_multimodal is None:

1383 - return super().get_input_embeddings(input_ids)

1383 + return super().embed_input_ids(input_ids)

1384

1385 - return super().get_input_embeddings(

1385 + return super().embed_input_ids(

1386 input_ids,

1387 multimodal_embeddings=multimodal_embeddings,

1388 is_multimodal=is_multimodal,

vllm/model_executor/models/jais.py

+4 -4

@@ -275,7 +275,7 @@ class JAISModel(nn.Module):

275 ["hidden_states"], config.n_embd

276 )

277

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

278 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

279 return self.wte(input_ids)

280

281 def forward(

@@ -287,7 +287,7 @@ class JAISModel(nn.Module):

287 ) -> IntermediateTensors | torch.Tensor:

288 if get_pp_group().is_first_rank:

289 if inputs_embeds is None:

290 - inputs_embeds = self.get_input_embeddings(input_ids)

290 + inputs_embeds = self.embed_input_ids(input_ids)

291 if self.wpe is not None:

292 position_embeds = self.wpe(position_ids)

293 hidden_states = inputs_embeds + position_embeds

@@ -339,8 +339,8 @@ class JAISLMHeadModel(nn.Module, SupportsPP):

339 self.transformer.make_empty_intermediate_tensors

340 )

341

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

343 - return self.transformer.get_input_embeddings(input_ids)

342 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

343 + return self.transformer.embed_input_ids(input_ids)

344

345 def forward(

346 self,

vllm/model_executor/models/jamba.py

+4 -4

@@ -340,7 +340,7 @@ class JambaModel(nn.Module):

340

341 self.final_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

342

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

343 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

344 return self.embed_tokens(input_ids)

345

346 def forward(

@@ -354,7 +354,7 @@ class JambaModel(nn.Module):

354 if inputs_embeds is not None:

355 hidden_states = inputs_embeds

356 else:

357 - hidden_states = self.get_input_embeddings(input_ids)

357 + hidden_states = self.embed_input_ids(input_ids)

358 residual = None

359 else:

360 assert intermediate_tensors is not None

@@ -508,8 +508,8 @@ class JambaForCausalLM(

508 self.model.make_empty_intermediate_tensors

509 )

510

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

512 - return self.model.get_input_embeddings(input_ids)

511 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

512 + return self.model.embed_input_ids(input_ids)

513

514 def forward(

515 self,

vllm/model_executor/models/keye.py

+1 -3

@@ -1484,9 +1484,7 @@ class BaseKeyeModule(nn.Module):

1484 def get_language_model(self) -> torch.nn.Module:

1485 return self.language_model

1486

1487 - def get_multimodal_embeddings(

1488 - self, **kwargs: object

1489 - ) -> MultiModalEmbeddings | None:

1487 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

1488 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1489 if not modalities:

1490 return None

vllm/model_executor/models/kimi_linear.py

+4 -4

@@ -439,7 +439,7 @@ class KimiLinearModel(nn.Module):

439 "num_attention_heads must be divisible by world_size"

440 )

441

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

442 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

443 return self.embed_tokens(input_ids)

444

445 def forward(

@@ -454,7 +454,7 @@ class KimiLinearModel(nn.Module):

454 if inputs_embeds is not None:

455 hidden_states = inputs_embeds

456 else:

457 - hidden_states = self.get_input_embeddings(input_ids)

457 + hidden_states = self.embed_input_ids(input_ids)

458 residual = None

459 else:

460 assert intermediate_tensors is not None

@@ -504,8 +504,8 @@ class KimiLinearForCausalLM(

504 self.config.vocab_size, scale=logit_scale

505 )

506

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

508 - return self.model.get_input_embeddings(input_ids)

507 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

508 + return self.model.embed_input_ids(input_ids)

509

510 def forward(

511 self,

vllm/model_executor/models/kimi_vl.py

+1 -1

@@ -404,7 +404,7 @@ class KimiVLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP):

404 def get_language_model(self) -> torch.nn.Module:

405 return self.language_model

406

407 - def get_multimodal_embeddings(self, **kwargs: object) -> NestedTensors | None:

407 + def embed_multimodal(self, **kwargs: object) -> NestedTensors | None:

408 # Validate the multimodal input keyword arguments

409 image_input = self._parse_and_validate_image_input(**kwargs)

410 if image_input is None:

vllm/model_executor/models/lfm2.py

+4 -4

@@ -351,7 +351,7 @@ class Lfm2Model(nn.Module):

351 else:

352 self.embedding_norm = PPMissingLayer()

353

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

354 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

355 return self.embed_tokens(input_ids)

356

357 def forward(

@@ -365,7 +365,7 @@ class Lfm2Model(nn.Module):

365 if inputs_embeds is not None:

366 hidden_states = inputs_embeds

367 else:

368 - hidden_states = self.get_input_embeddings(input_ids)

368 + hidden_states = self.embed_input_ids(input_ids)

369 residual = None

370 else:

371 assert intermediate_tensors is not None

@@ -504,8 +504,8 @@ class Lfm2ForCausalLM(

504 self.model.make_empty_intermediate_tensors

505 )

506

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

508 - return self.model.get_input_embeddings(input_ids)

507 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

508 + return self.model.embed_input_ids(input_ids)

509

510 def forward(

511 self,

vllm/model_executor/models/lfm2_moe.py

+4 -4

@@ -466,7 +466,7 @@ class Lfm2MoeModel(nn.Module):

466 else:

467 self.embedding_norm = PPMissingLayer()

468

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

469 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

470 return self.embed_tokens(input_ids)

471

472 def forward(

@@ -480,7 +480,7 @@ class Lfm2MoeModel(nn.Module):

480 if inputs_embeds is not None:

481 hidden_states = inputs_embeds

482 else:

483 - hidden_states = self.get_input_embeddings(input_ids)

483 + hidden_states = self.embed_input_ids(input_ids)

484 residual = None

485 else:

486 assert intermediate_tensors is not None

@@ -714,8 +714,8 @@ class Lfm2MoeForCausalLM(

714 self.num_routed_experts = example_layer.n_routed_experts

715 self.num_redundant_experts = example_layer.n_redundant_experts

716

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

718 - return self.model.get_input_embeddings(input_ids)

717 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

718 + return self.model.embed_input_ids(input_ids)

719

720 def update_physical_experts_metadata(

721 self,

vllm/model_executor/models/llama.py

+4 -4

@@ -424,7 +424,7 @@ class LlamaModel(nn.Module):

424 ["hidden_states", "residual"], config.hidden_size

425 )

426

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

427 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

428 return self.embed_tokens(input_ids)

429

430 def forward(

@@ -438,7 +438,7 @@ class LlamaModel(nn.Module):

438 if inputs_embeds is not None:

439 hidden_states = inputs_embeds

440 else:

441 - hidden_states = self.get_input_embeddings(input_ids)

441 + hidden_states = self.embed_input_ids(input_ids)

442 residual = None

443 else:

444 assert intermediate_tensors is not None

@@ -640,8 +640,8 @@ class LlamaForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

640 ):

641 return LlamaModel(vllm_config=vllm_config, prefix=prefix, layer_type=layer_type)

642

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

644 - return self.model.get_input_embeddings(input_ids)

643 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

644 + return self.model.embed_input_ids(input_ids)

645

646 def forward(

647 self,

vllm/model_executor/models/llama4_eagle.py

+3 -3

@@ -82,7 +82,7 @@ class LlamaModel(nn.Module):

82 )

83 self.norm = RMSNorm(self.config.hidden_size, eps=self.config.rms_norm_eps)

84

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

85 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

86 return self.embed_tokens(input_ids)

87

88 def forward(

@@ -93,7 +93,7 @@ class LlamaModel(nn.Module):

93 inputs_embeds: torch.Tensor | None = None,

94 ) -> tuple[torch.Tensor, torch.Tensor]:

95 if inputs_embeds is None:

96 - inputs_embeds = self.get_input_embeddings(input_ids)

96 + inputs_embeds = self.embed_input_ids(input_ids)

97 hidden_states = self.fc(torch.cat((inputs_embeds, hidden_states), dim=-1))

98 residual = None

99 for layer in self.layers:

@@ -195,7 +195,7 @@ class EagleLlama4ForCausalLM(Llama4ForCausalLM):

195 def get_language_model(self) -> torch.nn.Module:

196 return self.model

197

198 - get_input_embeddings = SupportsMultiModal.get_input_embeddings # type: ignore

198 + embed_input_ids = SupportsMultiModal.embed_input_ids # type: ignore

199

200 def forward(

201 self,

vllm/model_executor/models/llama_eagle.py

+3 -3

@@ -84,7 +84,7 @@ class LlamaModel(nn.Module):

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

85 )

86

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

87 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

88 return self.embed_tokens(input_ids)

89

90 def forward(

@@ -158,8 +158,8 @@ class EagleLlamaForCausalLM(LlamaForCausalLM):

158 self.config.vocab_size, scale=logit_scale

159 )

160

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

162 - return self.model.get_input_embeddings(input_ids)

161 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

162 + return self.model.embed_input_ids(input_ids)

163

164 def forward(

165 self,

vllm/model_executor/models/llama_eagle3.py

+4 -4

@@ -172,7 +172,7 @@ class LlamaModel(nn.Module):

172 eps=self.config.rms_norm_eps,

173 )

174

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

175 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

176 return self.embed_tokens(input_ids)

177

178 def forward(

@@ -183,7 +183,7 @@ class LlamaModel(nn.Module):

183 input_embeds: torch.Tensor | None = None,

184 ) -> tuple[torch.Tensor, torch.Tensor]:

185 if input_embeds is None:

186 - input_embeds = self.get_input_embeddings(input_ids)

186 + input_embeds = self.embed_input_ids(input_ids)

187 assert hidden_states.shape[-1] == input_embeds.shape[-1]

188

189 residual = None

@@ -261,13 +261,13 @@ class Eagle3LlamaForCausalLM(LlamaForCausalLM):

261 requires_grad=False,

262 )

263

264 - def get_input_embeddings(

264 + def embed_input_ids(

265 self,

266 input_ids: torch.Tensor,

267 multimodal_embeddings: NestedTensors | None = None,

268 is_multimodal: torch.Tensor | None = None,

269 ) -> torch.Tensor:

270 - return self.model.get_input_embeddings(input_ids)

270 + return self.model.embed_input_ids(input_ids)

271

272 def forward(

273 self,

vllm/model_executor/models/llava.py

+1 -1

@@ -661,7 +661,7 @@ class LlavaForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP):

661 def get_language_model(self) -> torch.nn.Module:

662 return self.language_model

663

664 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

664 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

665 image_input = self._parse_and_validate_image_input(**kwargs)

666 if image_input is None:

667 return []

vllm/model_executor/models/llava_next.py

+4 -4

@@ -483,14 +483,14 @@ class LlavaNextForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsP

483 def get_language_model(self) -> torch.nn.Module:

484 return self.language_model

485

486 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

486 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

487 image_input = self._parse_and_validate_image_input(**kwargs)

488 if image_input is None:

489 return []

490 vision_embeddings = self._process_image_input(image_input)

491 return vision_embeddings

492

493 - def get_input_embeddings(

493 + def embed_input_ids(

494 self,

495 input_ids: torch.Tensor,

496 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -501,9 +501,9 @@ class LlavaNextForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsP

501 ) -> torch.Tensor:

502 # This is to satisfy the type checker for each overload

503 if multimodal_embeddings is None or is_multimodal is None:

504 - return super().get_input_embeddings(input_ids)

504 + return super().embed_input_ids(input_ids)

505

506 - return super().get_input_embeddings(

506 + return super().embed_input_ids(

507 input_ids,

508 multimodal_embeddings=multimodal_embeddings,

509 is_multimodal=is_multimodal,

vllm/model_executor/models/llava_next_video.py

+1 -1

@@ -422,7 +422,7 @@ class LlavaNextVideoForConditionalGeneration(nn.Module, SupportsMultiModal, Supp

422 def get_language_model(self) -> torch.nn.Module:

423 return self.language_model

424

425 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

425 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

426 video_input = self._parse_and_validate_video_input(**kwargs)

427 if video_input is None:

428 return []

vllm/model_executor/models/llava_onevision.py

+1 -1

@@ -866,7 +866,7 @@ class LlavaOnevisionForConditionalGeneration(nn.Module, SupportsMultiModal, Supp

866 def get_language_model(self) -> torch.nn.Module:

867 return self.language_model

868

869 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

869 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

870 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

871 if not mm_input_by_modality:

872 return []

vllm/model_executor/models/longcat_flash.py

+4 -4

@@ -498,7 +498,7 @@ class FlashModel(nn.Module):

498 ["hidden_states", "residual"], config.hidden_size

499 )

500

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

501 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

502 return self.embed_tokens(input_ids)

503

504 def forward(

@@ -512,7 +512,7 @@ class FlashModel(nn.Module):

512 if inputs_embeds is not None:

513 hidden_states = inputs_embeds

514 else:

515 - hidden_states = self.get_input_embeddings(input_ids)

515 + hidden_states = self.embed_input_ids(input_ids)

516 residual = None

517 else:

518 assert intermediate_tensors is not None

@@ -583,8 +583,8 @@ class LongcatFlashForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

583 self.model.make_empty_intermediate_tensors

584 )

585

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

587 - return self.model.get_input_embeddings(input_ids)

586 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

587 + return self.model.embed_input_ids(input_ids)

588

589 def forward(

590 self,

vllm/model_executor/models/mamba.py

+4 -4

@@ -135,7 +135,7 @@ class MambaModel(nn.Module):

135 ["hidden_states", "residual"], config.hidden_size

136 )

137

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

138 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

139 return self.embeddings(input_ids)

140

141 def forward(

@@ -149,7 +149,7 @@ class MambaModel(nn.Module):

149 if inputs_embeds is not None:

150 hidden_states = inputs_embeds

151 else:

152 - hidden_states = self.get_input_embeddings(input_ids)

152 + hidden_states = self.embed_input_ids(input_ids)

153 residual = None

154 else:

155 assert intermediate_tensors is not None

@@ -218,8 +218,8 @@ class MambaForCausalLM(

218 self.backbone.make_empty_intermediate_tensors

219 )

220

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

222 - return self.backbone.get_input_embeddings(input_ids)

221 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

222 + return self.backbone.embed_input_ids(input_ids)

223

224 def forward(

225 self,

vllm/model_executor/models/mamba2.py

+4 -4

@@ -131,7 +131,7 @@ class Mamba2Model(nn.Module):

131 ["hidden_states", "residual"], config.hidden_size

132 )

133

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

134 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

135 return self.embeddings(input_ids)

136

137 def forward(

@@ -145,7 +145,7 @@ class Mamba2Model(nn.Module):

145 if inputs_embeds is not None:

146 hidden_states = inputs_embeds

147 else:

148 - hidden_states = self.get_input_embeddings(input_ids)

148 + hidden_states = self.embed_input_ids(input_ids)

149 residual = None

150 else:

151 assert intermediate_tensors is not None

@@ -257,8 +257,8 @@ class Mamba2ForCausalLM(

257 self.backbone.make_empty_intermediate_tensors

258 )

259

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

261 - return self.backbone.get_input_embeddings(input_ids)

260 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

261 + return self.backbone.embed_input_ids(input_ids)

262

263 def forward(

264 self,

vllm/model_executor/models/midashenglm.py

+1 -1

@@ -791,7 +791,7 @@ class MiDashengLMModel(nn.Module, SupportsMultiModal, SupportsPP):

791 def get_language_model(self) -> torch.nn.Module:

792 return self.decoder

793

794 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

794 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

795 audio_input = self._parse_and_validate_audio_input(**kwargs)

796

797 if audio_input is None:

vllm/model_executor/models/mimo.py

+1 -1

@@ -70,7 +70,7 @@ class MiMoModel(Qwen2Model):

70 if inputs_embeds is not None:

71 hidden_states = inputs_embeds

72 else:

73 - hidden_states = self.get_input_embeddings(input_ids)

73 + hidden_states = self.embed_input_ids(input_ids)

74 residual = None

75 else:

76 assert intermediate_tensors is not None

vllm/model_executor/models/mimo_mtp.py

+3 -3

@@ -120,7 +120,7 @@ class MiMoMultiTokenPredictor(nn.Module):

120

121 self.logits_processor = LogitsProcessor(config.vocab_size)

122

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

123 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

124 return self.embed_tokens(input_ids)

125

126 def forward(

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

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

165 )

166

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

168 - return self.model.get_input_embeddings(input_ids)

167 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

168 + return self.model.embed_input_ids(input_ids)

169

170 def forward(

171 self,

vllm/model_executor/models/minicpm.py

+4 -4

@@ -440,7 +440,7 @@ class MiniCPMModel(nn.Module):

440 prefix=f"{prefix}.layers",

441 )

442

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

443 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

444 embedding = self.embed_tokens(input_ids)

445 return embedding * self.config.scale_emb

446

@@ -455,7 +455,7 @@ class MiniCPMModel(nn.Module):

455 if inputs_embeds is not None:

456 hidden_states = inputs_embeds

457 else:

458 - hidden_states = self.get_input_embeddings(input_ids)

458 + hidden_states = self.embed_input_ids(input_ids)

459 residual = None

460 else:

461 hidden_states = intermediate_tensors["hidden_states"]

@@ -615,8 +615,8 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsEagle3):

615 def _init_model(self, *, vllm_config: VllmConfig, prefix: str = ""):

616 return MiniCPMModel(vllm_config=vllm_config, prefix=prefix)

617

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

619 - return self.model.get_input_embeddings(input_ids)

618 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

619 + return self.model.embed_input_ids(input_ids)

620

621 def set_aux_hidden_state_layers(self, layers: tuple[int, ...]) -> None:

622 self.model.aux_hidden_state_layers = layers

vllm/model_executor/models/minicpm_eagle.py

+4 -4

@@ -193,7 +193,7 @@ class EagleMiniCPMModel(nn.Module):

193 ]

194 )

195

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

196 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

197 embedding = self.embed_tokens(input_ids)

198 return embedding * self.config.scale_emb

199

@@ -203,7 +203,7 @@ class EagleMiniCPMModel(nn.Module):

203 positions: torch.Tensor,

204 hidden_states: torch.Tensor,

205 ) -> torch.Tensor | IntermediateTensors:

206 - input_embeds = self.get_input_embeddings(input_ids)

206 + input_embeds = self.embed_input_ids(input_ids)

207 input_embeds = self.input_norm1(input_embeds)

208 hidden_states = self.input_norm2(hidden_states)

209

@@ -354,8 +354,8 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

354 vllm_config=vllm_config, prefix=prefix, start_layer=start_layer

355 )

356

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

358 - return self.model.get_input_embeddings(input_ids)

357 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

358 + return self.model.embed_input_ids(input_ids)

359

360 def forward(

361 self,

vllm/model_executor/models/minicpmv.py

+1 -1

@@ -1139,7 +1139,7 @@ class MiniCPMVBaseModel(nn.Module, SupportsMultiModal, SupportsPP):

1139 def get_language_model(self) -> torch.nn.Module:

1140 return self.llm

1141

1142 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1142 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1143 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1144 if not modalities:

1145 return []

vllm/model_executor/models/minimax_m2.py

+4 -4

@@ -360,7 +360,7 @@ class MiniMaxM2Model(nn.Module):

360 ["hidden_states", "residual"], config.hidden_size

361 )

362

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

363 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

364 return self.embed_tokens(input_ids)

365

366 def forward(

@@ -374,7 +374,7 @@ class MiniMaxM2Model(nn.Module):

374 if inputs_embeds is not None:

375 hidden_states = inputs_embeds

376 else:

377 - hidden_states = self.get_input_embeddings(input_ids)

377 + hidden_states = self.embed_input_ids(input_ids)

378 residual = None

379 else:

380 assert intermediate_tensors is not None

@@ -510,8 +510,8 @@ class MiniMaxM2ForCausalLM(nn.Module, SupportsPP):

510 self.model.make_empty_intermediate_tensors

511 )

512

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

514 - return self.model.get_input_embeddings(input_ids)

513 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

514 + return self.model.embed_input_ids(input_ids)

515

516 def forward(

517 self,

vllm/model_executor/models/minimax_text_01.py

+3 -3

@@ -620,7 +620,7 @@ class MiniMaxText01Model(nn.Module):

620 )

621 minimax_cache_tensors[:, slots_tensor, ...] = 0

622

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

623 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

624 return self.embed_tokens(input_ids)

625

626 def forward(

@@ -709,8 +709,8 @@ class MiniMaxText01ForCausalLM(nn.Module, HasInnerState, IsHybrid):

709 def get_seqlen_agnostic_capture_inputs(self, batch_size: int):

710 return self.model.minimax_cache.get_seqlen_agnostic_capture_inputs(batch_size)

711

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

713 - return self.model.get_input_embeddings(input_ids)

712 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

713 + return self.model.embed_input_ids(input_ids)

714

715 def forward(

716 self,

vllm/model_executor/models/minimax_vl_01.py

+3 -3

@@ -353,7 +353,7 @@ class MiniMaxVL01ForConditionalGeneration(nn.Module, SupportsMultiModal, Support

353

354 raise AssertionError("This line should be unreachable.")

355

356 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

356 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

357 image_input = self._parse_and_validate_image_input(**kwargs)

358 if image_input is None:

359 return []

@@ -371,8 +371,8 @@ class MiniMaxVL01ForConditionalGeneration(nn.Module, SupportsMultiModal, Support

371 if intermediate_tensors is not None:

372 inputs_embeds = None

373 elif inputs_embeds is None:

374 - vision_embeddings = self.get_multimodal_embeddings(**kwargs)

375 - inputs_embeds = self.get_input_embeddings(

374 + vision_embeddings = self.embed_multimodal(**kwargs)

375 + inputs_embeds = self.embed_input_ids(

376 input_ids,

377 vision_embeddings,

378 is_multimodal=input_ids == self.config.image_token_index,

vllm/model_executor/models/mistral3.py

+1 -1

@@ -549,7 +549,7 @@ class Mistral3ForConditionalGeneration(

549 def get_language_model(self) -> torch.nn.Module:

550 return self.language_model

551

552 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

552 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

553 image_input = self._parse_and_validate_image_input(**kwargs)

554 if image_input is None:

555 return []

vllm/model_executor/models/mixtral.py

+4 -4

@@ -345,7 +345,7 @@ class MixtralModel(nn.Module):

345 ["hidden_states", "residual"], config.hidden_size

346 )

347

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

348 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

349 return self.embed_tokens(input_ids)

350

351 def forward(

@@ -359,7 +359,7 @@ class MixtralModel(nn.Module):

359 if inputs_embeds is not None:

360 hidden_states = inputs_embeds

361 else:

362 - hidden_states = self.get_input_embeddings(input_ids)

362 + hidden_states = self.embed_input_ids(input_ids)

363 residual = None

364 else:

365 assert intermediate_tensors is not None

@@ -591,8 +591,8 @@ class MixtralForCausalLM(nn.Module, SupportsLoRA, SupportsPP, MixtureOfExperts):

591 moe.n_redundant_experts = self.num_redundant_experts

592 moe.experts.update_expert_map()

593

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

595 - return self.model.get_input_embeddings(input_ids)

594 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

595 + return self.model.embed_input_ids(input_ids)

596

597 def forward(

598 self,

vllm/model_executor/models/mllama4.py

+1 -1

@@ -865,7 +865,7 @@ class Llama4ForConditionalGeneration(

865 def get_language_model(self) -> torch.nn.Module:

866 return self.language_model

867

868 - def get_multimodal_embeddings(self, **kwargs) -> MultiModalEmbeddings:

868 + def embed_multimodal(self, **kwargs) -> MultiModalEmbeddings:

869 image_input = self._parse_and_validate_image_input(**kwargs)

870 if image_input is None:

871 return []

vllm/model_executor/models/modernbert.py

+7 -7

@@ -46,7 +46,7 @@ class ModernBertEmbeddings(nn.Module):

46 )

47 self.norm = nn.LayerNorm(config.hidden_size, eps=eps, bias=config.norm_bias)

48

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

49 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

50 return self.tok_embeddings(input_ids)

51

52 def forward(

@@ -225,8 +225,8 @@ class ModernBertModel(nn.Module):

225 config.hidden_size, eps=config.norm_eps, bias=config.norm_bias

226 )

227

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

229 - return self.embeddings.get_input_embeddings(input_ids)

228 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

229 + return self.embeddings.embed_input_ids(input_ids)

230

231 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:

232 weights = self.hf_to_vllm_mapper.apply(weights)

@@ -337,8 +337,8 @@ class ModernBertForSequenceClassification(nn.Module, SupportsCrossEncoding):

337 }

338 )

339

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

341 - return self.model.get_input_embeddings(input_ids)

340 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

341 + return self.model.embed_input_ids(input_ids)

342

343 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):

344 self_weights = []

@@ -424,8 +424,8 @@ class ModernBertForTokenClassification(nn.Module):

424 }

425 )

426

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

428 - return self.model.get_input_embeddings(input_ids)

427 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

428 + return self.model.embed_input_ids(input_ids)

429

430 def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]):

431 loader = AutoWeightsLoader(self, skip_prefixes=["drop"])

vllm/model_executor/models/molmo.py

+2 -2

@@ -832,7 +832,7 @@ class MolmoModel(nn.Module, SupportsQuant):

832 ["hidden_states", "residual"], config.hidden_size

833 )

834

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

835 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

836 return self.embed_tokens(input_ids)

837

838 def forward(

@@ -1491,7 +1491,7 @@ class MolmoForCausalLM(

1491 def get_language_model(self) -> torch.nn.Module:

1492 return self.model

1493

1494 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1494 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1495 image_input = self._parse_and_validate_image_input(**kwargs)

1496 if image_input is None:

1497 return []

vllm/model_executor/models/mpt.py

+4 -4

@@ -248,7 +248,7 @@ class MPTModel(nn.Module):

248 ["hidden_states"], config.d_model

249 )

250

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

251 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

252 return self.wte(input_ids)

253

254 def forward(

@@ -262,7 +262,7 @@ class MPTModel(nn.Module):

262 if inputs_embeds is not None:

263 hidden_states = inputs_embeds

264 else:

265 - hidden_states = self.get_input_embeddings(input_ids)

265 + hidden_states = self.embed_input_ids(input_ids)

266 else:

267 assert intermediate_tensors is not None

268 hidden_states = intermediate_tensors["hidden_states"]

@@ -308,8 +308,8 @@ class MPTForCausalLM(nn.Module, SupportsPP):

308 self.transformer.make_empty_intermediate_tensors

309 )

310

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

312 - return self.transformer.get_input_embeddings(input_ids)

311 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

312 + return self.transformer.embed_input_ids(input_ids)

313

314 def forward(

315 self,

vllm/model_executor/models/nano_nemotron_vl.py

+3 -3

@@ -655,7 +655,7 @@ class NanoNemotronVLProcessor(BaseNanoNemotronVLProcessor):

655 The replacement returned is not actually used to replace the placeholder

656 tokens - it's just used to make sure we allocate the correct number

657 of tokens.

658 - Actual replacement is done in get_multimodal_embeddings of

658 + Actual replacement is done in embed_multimodal of

659 NemotronH_Nano_VL_V2

660 (specifically in _process_video_input -> _create_final_video_embeddings).

661 There, we create the final embeddings with text embeddings for indicator tokens

@@ -1401,7 +1401,7 @@ class NemotronH_Nano_VL_V2(

1401

1402 # Create final video embeddings, merging text embeddings for indicator

1403 # tokens with video embeddings

1404 - text_embeddings = self.get_language_model().get_input_embeddings(repl_token_ids)

1404 + text_embeddings = self.get_language_model().embed_input_ids(repl_token_ids)

1405 final_video_embeddings = _merge_multimodal_embeddings(

1406 inputs_embeds=text_embeddings,

1407 multimodal_embeddings=video_embeddings,

@@ -1465,7 +1465,7 @@ class NemotronH_Nano_VL_V2(

1465

1466 return modalities

1467

1468 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1468 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1469 # Validate the multimodal input keyword arguments

1470 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1471 if modalities is None:

vllm/model_executor/models/nemotron.py

+4 -4

@@ -351,7 +351,7 @@ class NemotronModel(nn.Module):

351 ["hidden_states", "residual"], config.hidden_size

352 )

353

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

354 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

355 return self.embed_tokens(input_ids)

356

357 def forward(

@@ -365,7 +365,7 @@ class NemotronModel(nn.Module):

365 if inputs_embeds is not None:

366 hidden_states = inputs_embeds

367 else:

368 - hidden_states = self.get_input_embeddings(input_ids)

368 + hidden_states = self.embed_input_ids(input_ids)

369 residual = None

370 else:

371 assert intermediate_tensors is not None

@@ -491,8 +491,8 @@ class NemotronForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

491 self.model.make_empty_intermediate_tensors

492 )

493

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

495 - return self.model.get_input_embeddings(input_ids)

494 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

495 + return self.model.embed_input_ids(input_ids)

496

497 def forward(

498 self,

vllm/model_executor/models/nemotron_h.py

+4 -4

@@ -548,7 +548,7 @@ class NemotronHModel(nn.Module):

548

549 self.norm_f = RMSNorm(config.hidden_size, eps=config.layer_norm_epsilon)

550

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

551 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

552 return self.embed_tokens(input_ids)

553

554 def forward(

@@ -562,7 +562,7 @@ class NemotronHModel(nn.Module):

562 if inputs_embeds is not None:

563 hidden_states = inputs_embeds

564 else:

565 - hidden_states = self.get_input_embeddings(input_ids)

565 + hidden_states = self.embed_input_ids(input_ids)

566 residual = None

567 else:

568 assert intermediate_tensors is not None

@@ -823,8 +823,8 @@ class NemotronHForCausalLM(

823 moe.n_redundant_experts = self.num_redundant_experts

824 moe.experts.update_expert_map()

825

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

827 - return self.model.get_input_embeddings(input_ids)

826 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

827 + return self.model.embed_input_ids(input_ids)

828

829 def forward(

830 self,

vllm/model_executor/models/nemotron_nas.py

+4 -4

@@ -291,7 +291,7 @@ class DeciModel(nn.Module):

291 ["hidden_states", "residual"], config.hidden_size

292 )

293

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

294 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

295 return self.embed_tokens(input_ids)

296

297 def forward(

@@ -305,7 +305,7 @@ class DeciModel(nn.Module):

305 if inputs_embeds is not None:

306 hidden_states = inputs_embeds

307 else:

308 - hidden_states = self.get_input_embeddings(input_ids)

308 + hidden_states = self.embed_input_ids(input_ids)

309 residual = None

310 else:

311 assert intermediate_tensors is not None

@@ -461,8 +461,8 @@ class DeciLMForCausalLM(nn.Module, SupportsLoRA, SupportsPP, HasNoOps):

461 def _init_model(self, vllm_config: VllmConfig, prefix: str = ""):

462 return DeciModel(vllm_config=vllm_config, prefix=prefix)

463

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

465 - return self.model.get_input_embeddings(input_ids)

464 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

465 + return self.model.embed_input_ids(input_ids)

466

467 def forward(

468 self,

vllm/model_executor/models/nemotron_vl.py

+4 -4

@@ -561,7 +561,7 @@ class LlamaNemotronVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, Suppor

561 def get_language_model(self) -> torch.nn.Module:

562 return self.language_model

563

564 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

564 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

565 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

566 if not modalities:

567 return []

@@ -580,7 +580,7 @@ class LlamaNemotronVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, Suppor

580

581 return multimodal_embeddings

582

583 - def get_input_embeddings(

583 + def embed_input_ids(

584 self,

585 input_ids: torch.Tensor,

586 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -593,9 +593,9 @@ class LlamaNemotronVLChatModel(nn.Module, SupportsMultiModal, SupportsPP, Suppor

593

594 # This is to satisfy the type checker for each overload

595 if multimodal_embeddings is None or is_multimodal is None:

596 - return super().get_input_embeddings(input_ids)

596 + return super().embed_input_ids(input_ids)

597

598 - return super().get_input_embeddings(

598 + return super().embed_input_ids(

599 input_ids,

600 multimodal_embeddings=multimodal_embeddings,

601 is_multimodal=is_multimodal,

vllm/model_executor/models/olmo.py

+4 -4

@@ -268,7 +268,7 @@ class OlmoModel(nn.Module):

268 ["hidden_states"], config.hidden_size

269 )

270

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

271 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

272 return self.embed_tokens(input_ids)

273

274 def forward(

@@ -285,7 +285,7 @@ class OlmoModel(nn.Module):

285 if inputs_embeds is not None:

286 hidden_states = inputs_embeds

287 else:

288 - hidden_states = self.get_input_embeddings(input_ids)

288 + hidden_states = self.embed_input_ids(input_ids)

289 else:

290 assert intermediate_tensors is not None

291 hidden_states = intermediate_tensors["hidden_states"]

@@ -379,8 +379,8 @@ class OlmoForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

379 self.model.make_empty_intermediate_tensors

380 )

381

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

383 - return self.model.get_input_embeddings(input_ids)

382 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

383 + return self.model.embed_input_ids(input_ids)

384

385 def forward(

386 self,

vllm/model_executor/models/olmo2.py

+3 -3

@@ -304,7 +304,7 @@ class Olmo2Model(nn.Module):

304 ["hidden_states"], self.config.hidden_size

305 )

306

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

307 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

308 return self.embed_tokens(input_ids)

309

310 def forward(

@@ -419,8 +419,8 @@ class Olmo2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

419 self.model.make_empty_intermediate_tensors

420 )

421

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

423 - return self.model.get_input_embeddings(input_ids)

422 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

423 + return self.model.embed_input_ids(input_ids)

424

425 def forward(

426 self,

vllm/model_executor/models/olmoe.py

+4 -4

@@ -296,7 +296,7 @@ class OlmoeModel(nn.Module):

296 ["hidden_states", "residual"], config.hidden_size

297 )

298

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

299 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

300 return self.embed_tokens(input_ids)

301

302 def forward(

@@ -310,7 +310,7 @@ class OlmoeModel(nn.Module):

310 if inputs_embeds is not None:

311 hidden_states = inputs_embeds

312 else:

313 - hidden_states = self.get_input_embeddings(input_ids)

313 + hidden_states = self.embed_input_ids(input_ids)

314 residual = None

315 else:

316 assert intermediate_tensors is not None

@@ -471,8 +471,8 @@ class OlmoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

471 self.model.make_empty_intermediate_tensors

472 )

473

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

475 - return self.model.get_input_embeddings(input_ids)

474 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

475 + return self.model.embed_input_ids(input_ids)

476

477 def forward(

478 self,

vllm/model_executor/models/openpangu.py

+4 -4

@@ -753,7 +753,7 @@ class OpenPanguModel(nn.Module):

753 ["hidden_states", "residual"], config.hidden_size

754 )

755

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

756 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

757 return self.embed_tokens(input_ids)

758

759 def forward(

@@ -767,7 +767,7 @@ class OpenPanguModel(nn.Module):

767 if inputs_embeds is not None:

768 hidden_states = inputs_embeds

769 else:

770 - hidden_states = self.get_input_embeddings(input_ids)

770 + hidden_states = self.embed_input_ids(input_ids)

771 residual = None

772 else:

773 assert intermediate_tensors is not None

@@ -969,8 +969,8 @@ class OpenPanguModelBase(nn.Module, SupportsPP, SupportsLoRA):

969 self.model.make_empty_intermediate_tensors

970 )

971

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

973 - return self.model.get_input_embeddings(input_ids)

972 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

973 + return self.model.embed_input_ids(input_ids)

974

975 def forward(

976 self,

vllm/model_executor/models/openpangu_mtp.py

+2 -2

@@ -100,8 +100,8 @@ class OpenPanguMTP(nn.Module, SupportsPP):

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

101 )

102

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

104 - return self.model.get_input_embeddings(input_ids)

103 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

104 + return self.model.embed_input_ids(input_ids)

105

106 def forward(

107 self,

vllm/model_executor/models/opt.py

+6 -6

@@ -262,7 +262,7 @@ class OPTDecoder(nn.Module):

262 prefix=f"{prefix}.layers",

263 )

264

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

265 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

266 return self.embed_tokens(input_ids)

267

268 def forward(

@@ -274,7 +274,7 @@ class OPTDecoder(nn.Module):

274 ) -> torch.Tensor | IntermediateTensors:

275 if get_pp_group().is_first_rank:

276 if inputs_embeds is None:

277 - inputs_embeds = self.get_input_embeddings(input_ids)

277 + inputs_embeds = self.embed_input_ids(input_ids)

278 pos_embeds = self.embed_positions(positions)

279 if self.project_in is not None:

280 inputs_embeds, _ = self.project_in(inputs_embeds)

@@ -311,8 +311,8 @@ class OPTModel(nn.Module):

311 ["hidden_states"], config.hidden_size

312 )

313

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

315 - return self.decoder.get_input_embeddings(input_ids)

314 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

315 + return self.decoder.embed_input_ids(input_ids)

316

317 def forward(

318 self,

@@ -394,8 +394,8 @@ class OPTForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

394 self.model.make_empty_intermediate_tensors

395 )

396

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

398 - return self.model.get_input_embeddings(input_ids)

397 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

398 + return self.model.embed_input_ids(input_ids)

399

400 def forward(

401 self,

vllm/model_executor/models/orion.py

+4 -4

@@ -255,7 +255,7 @@ class OrionModel(nn.Module):

255 config.hidden_size,

256 )

257

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

258 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

259 return self.embed_tokens(input_ids)

260

261 def forward(

@@ -269,7 +269,7 @@ class OrionModel(nn.Module):

269 if inputs_embeds is not None:

270 hidden_states = inputs_embeds

271 else:

272 - hidden_states = self.get_input_embeddings(input_ids)

272 + hidden_states = self.embed_input_ids(input_ids)

273 else:

274 assert intermediate_tensors is not None

275 hidden_states = intermediate_tensors["hidden_states"]

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

345 self.model.make_empty_intermediate_tensors

346 )

347

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

349 - return self.model.get_input_embeddings(input_ids)

348 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

349 + return self.model.embed_input_ids(input_ids)

350

351 def forward(

352 self,

vllm/model_executor/models/ouro.py

+4 -4

@@ -361,7 +361,7 @@ class OuroModel(nn.Module):

361

362 self.total_ut_steps = getattr(self.config, "total_ut_steps", 4)

363

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

364 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

365 return self.embed_tokens(input_ids)

366

367 def forward(

@@ -374,7 +374,7 @@ class OuroModel(nn.Module):

374 if inputs_embeds is not None:

375 hidden_states = inputs_embeds

376 else:

377 - hidden_states = self.get_input_embeddings(input_ids)

377 + hidden_states = self.embed_input_ids(input_ids)

378

379 for current_ut in range(self.total_ut_steps):

380 residual = None

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

486 self.model.make_empty_intermediate_tensors

487 )

488

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

490 - return self.model.get_input_embeddings(input_ids)

489 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

490 + return self.model.embed_input_ids(input_ids)

491

492 def forward(

493 self,

vllm/model_executor/models/ovis.py

+1 -1

@@ -514,7 +514,7 @@ class Ovis(nn.Module, SupportsMultiModal, SupportsPP):

514

515 return tuple(vision_embeddings)

516

517 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

517 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

518 image_input = self._parse_and_validate_image_input(**kwargs)

519 if image_input is None:

520 return []

vllm/model_executor/models/ovis2_5.py

+1 -1

@@ -617,7 +617,7 @@ class Ovis2_5(nn.Module, SupportsMultiModal, SupportsPP):

617

618 return modalities

619

620 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

620 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

621 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

622 if not modalities:

623 return []

vllm/model_executor/models/paddleocr_vl.py

+3 -3

@@ -1328,10 +1328,10 @@ class PaddleOCRVLForConditionalGeneration(nn.Module, SupportsMultiModal, Support

1328 inputs_embeds = None

1329

1330 elif inputs_embeds is None:

1331 - vision_embeddings = self.get_multimodal_embeddings(**kwargs)

1331 + vision_embeddings = self.embed_multimodal(**kwargs)

1332 is_multimodal = kwargs.pop("is_multimodal", None)

1333 handle_oov_mm_token = kwargs.pop("handle_oov_mm_token", False)

1334 - inputs_embeds = self.get_input_embeddings(

1334 + inputs_embeds = self.embed_input_ids(

1335 input_ids,

1336 vision_embeddings,

1337 is_multimodal=is_multimodal,

@@ -1391,7 +1391,7 @@ class PaddleOCRVLForConditionalGeneration(nn.Module, SupportsMultiModal, Support

1391 image_embeds = self.mlp_AR(vision_outputs, image_grid_thw)

1392 return image_embeds

1393

1394 - def get_multimodal_embeddings(self, **kwargs) -> MultiModalEmbeddings:

1394 + def embed_multimodal(self, **kwargs) -> MultiModalEmbeddings:

1395 image_input = self._parse_and_validate_image_input(**kwargs)

1396 if image_input is None:

1397 return ()

vllm/model_executor/models/paligemma.py

+1 -1

@@ -375,7 +375,7 @@ class PaliGemmaForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsP

375 def get_language_model(self) -> torch.nn.Module:

376 return self.language_model

377

378 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

378 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

379 image_input = self._parse_and_validate_image_input(**kwargs)

380 if image_input is None:

381 return []

vllm/model_executor/models/persimmon.py

+4 -4

@@ -270,7 +270,7 @@ class PersimmonModel(nn.Module):

270 ["hidden_states"], config.hidden_size

271 )

272

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

273 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

274 return self.embed_tokens(input_ids)

275

276 def forward(

@@ -284,7 +284,7 @@ class PersimmonModel(nn.Module):

284 if inputs_embeds is not None:

285 hidden_states = inputs_embeds

286 else:

287 - hidden_states = self.get_input_embeddings(input_ids)

287 + hidden_states = self.embed_input_ids(input_ids)

288 else:

289 assert intermediate_tensors is not None

290 hidden_states = intermediate_tensors["hidden_states"]

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

347 self.model.make_empty_intermediate_tensors

348 )

349

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

351 - return self.model.get_input_embeddings(input_ids)

350 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

351 + return self.model.embed_input_ids(input_ids)

352

353 def forward(

354 self,

vllm/model_executor/models/phi.py

+4 -4

@@ -240,7 +240,7 @@ class PhiModel(nn.Module):

240 ["hidden_states"], config.hidden_size

241 )

242

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

243 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

244 return self.embed_tokens(input_ids)

245

246 def forward(

@@ -254,7 +254,7 @@ class PhiModel(nn.Module):

254 if inputs_embeds is not None:

255 hidden_states = inputs_embeds

256 else:

257 - hidden_states = self.get_input_embeddings(input_ids)

257 + hidden_states = self.embed_input_ids(input_ids)

258 else:

259 assert intermediate_tensors is not None

260 hidden_states = intermediate_tensors["hidden_states"]

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

346 self.model.make_empty_intermediate_tensors

347 )

348

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

350 - return self.model.get_input_embeddings(input_ids)

349 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

350 + return self.model.embed_input_ids(input_ids)

351

352 def forward(

353 self,

vllm/model_executor/models/phi3v.py

+4 -4

@@ -664,14 +664,14 @@ class Phi3VForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsQuant)

664 def get_language_model(self) -> torch.nn.Module:

665 return self.language_model

666

667 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

667 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

668 image_input = self._parse_and_validate_image_input(**kwargs)

669 if image_input is None:

670 return []

671 vision_embeddings = self._process_image_input(image_input)

672 return vision_embeddings

673

674 - def get_input_embeddings(

674 + def embed_input_ids(

675 self,

676 input_ids: torch.Tensor,

677 multimodal_embeddings: MultiModalEmbeddings | None = None,

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

679 is_multimodal: torch.Tensor | None = None,

680 handle_oov_mm_token: bool = False,

681 ) -> torch.Tensor:

682 - inputs_embeds = self._get_text_embeddings(

682 + inputs_embeds = self._embed_text_input_ids(

683 input_ids,

684 self.embed_tokens,

685 is_multimodal=is_multimodal,

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

691

692 if is_multimodal is None:

693 raise ValueError(

694 - "`get_input_embeddings` now requires `is_multimodal` arg, "

694 + "`embed_input_ids` now requires `is_multimodal` arg, "

695 "please update your model runner according to "

696 "https://github.com/vllm-project/vllm/pull/16229."

697 )

vllm/model_executor/models/phi4_multimodal.py

+1 -1

@@ -1371,7 +1371,7 @@ class Phi4MultimodalForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

1371 )

1372 return image_embeds

1373

1374 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1374 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1375 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1376 if not modalities:

1377 return []

vllm/model_executor/models/phi4mm.py

+1 -1

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

1180 )

1181 return image_embeds

1182

1183 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1183 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1184 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1185 if not modalities:

1186 return []

vllm/model_executor/models/phimoe.py

+4 -4

@@ -482,7 +482,7 @@ class PhiMoEModel(nn.Module):

482 ["hidden_states", "residual"], config.hidden_size

483 )

484

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

485 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

486 return self.embed_tokens(input_ids)

487

488 def forward(

@@ -496,7 +496,7 @@ class PhiMoEModel(nn.Module):

496 if inputs_embeds is not None:

497 hidden_states = inputs_embeds

498 else:

499 - hidden_states = self.get_input_embeddings(input_ids)

499 + hidden_states = self.embed_input_ids(input_ids)

500 residual = None

501 else:

502 assert intermediate_tensors is not None

@@ -648,8 +648,8 @@ class PhiMoEForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

648 self.model.make_empty_intermediate_tensors

649 )

650

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

652 - return self.model.get_input_embeddings(input_ids)

651 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

652 + return self.model.embed_input_ids(input_ids)

653

654 def forward(

655 self,

vllm/model_executor/models/pixtral.py

+1 -1

@@ -461,7 +461,7 @@ class PixtralForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

461 def get_language_model(self) -> torch.nn.Module:

462 return self.language_model

463

464 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

464 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

465 image_input = self._parse_and_validate_image_input(**kwargs)

466 if image_input is None:

467 return []

vllm/model_executor/models/plamo2.py

+4 -4

@@ -762,7 +762,7 @@ class Plamo2Model(torch.nn.Module):

762 self.layers = Plamo2Decoder(vllm_config=vllm_config, prefix=f"{prefix}.layers")

763 self.norm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

764

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

765 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

766 return self.embed_tokens(input_ids)

767

768 def forward(

@@ -776,7 +776,7 @@ class Plamo2Model(torch.nn.Module):

776 if inputs_embeds is not None:

777 hidden_states = inputs_embeds

778 else:

779 - hidden_states = self.get_input_embeddings(input_ids)

779 + hidden_states = self.embed_input_ids(input_ids)

780 residual = None

781 else:

782 assert intermediate_tensors is not None

@@ -839,8 +839,8 @@ class Plamo2ForCausalLM(torch.nn.Module, HasInnerState, SupportsPP, IsHybrid):

839 self.model.make_empty_intermediate_tensors

840 )

841

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

843 - return self.model.get_input_embeddings(input_ids)

842 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

843 + return self.model.embed_input_ids(input_ids)

844

845 def forward(

846 self,

vllm/model_executor/models/qwen.py

+2 -2

@@ -221,7 +221,7 @@ class QWenModel(nn.Module):

221 ["hidden_states", "residual"], config.hidden_size

222 )

223

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

224 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

225 return self.wte(input_ids)

226

227 def forward(

@@ -235,7 +235,7 @@ class QWenModel(nn.Module):

235 if inputs_embeds is not None:

236 hidden_states = inputs_embeds

237 else:

238 - hidden_states = self.get_input_embeddings(input_ids)

238 + hidden_states = self.embed_input_ids(input_ids)

239 residual = None

240 else:

241 assert intermediate_tensors is not None

vllm/model_executor/models/qwen2.py

+4 -4

@@ -355,7 +355,7 @@ class Qwen2Model(nn.Module):

355

356 self.aux_hidden_state_layers = tuple[int, ...]()

357

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

358 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

359 return self.embed_tokens(input_ids)

360

361 def forward(

@@ -369,7 +369,7 @@ class Qwen2Model(nn.Module):

369 if inputs_embeds is not None:

370 hidden_states = inputs_embeds

371 else:

372 - hidden_states = self.get_input_embeddings(input_ids)

372 + hidden_states = self.embed_input_ids(input_ids)

373 residual = None

374 else:

375 assert intermediate_tensors is not None

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

504 self.model.make_empty_intermediate_tensors

505 )

506

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

508 - return self.model.get_input_embeddings(input_ids)

507 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

508 + return self.model.embed_input_ids(input_ids)

509

510 def set_aux_hidden_state_layers(self, layers: tuple[int, ...]) -> None:

511 self.model.aux_hidden_state_layers = layers

vllm/model_executor/models/qwen2_5_omni_thinker.py

+5 -5

@@ -1132,7 +1132,7 @@ class Qwen2_5OmniThinkerForConditionalGeneration(

1132

1133 return llm_positions, mrope_position_delta

1134

1135 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1135 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1136 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

1137 if not mm_input_by_modality:

1138 return []

@@ -1158,7 +1158,7 @@ class Qwen2_5OmniThinkerForConditionalGeneration(

1158

1159 # TODO (ywang96): support overlapping modality embeddings so that

1160 # `use_audio_in_video` will work on V1.

1161 - def get_input_embeddings(

1161 + def embed_input_ids(

1162 self,

1163 input_ids: torch.Tensor,

1164 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1168,16 +1168,16 @@ class Qwen2_5OmniThinkerForConditionalGeneration(

1168 ) -> torch.Tensor:

1169 # This is to satisfy the type checker for each overload

1170 if multimodal_embeddings is None or is_multimodal is None:

1171 - return super().get_input_embeddings(input_ids)

1171 + return super().embed_input_ids(input_ids)

1172

1173 - return super().get_input_embeddings(

1173 + return super().embed_input_ids(

1174 input_ids,

1175 multimodal_embeddings=multimodal_embeddings,

1176 is_multimodal=is_multimodal,

1177 handle_oov_mm_token=handle_oov_mm_token,

1178 )

1179

1180 - def get_multimodal_embeddings_v0(self, **kwargs: object) -> NestedTensors | None:

1180 + def embed_multimodal_v0(self, **kwargs: object) -> NestedTensors | None:

1181 audio_input = self._parse_and_validate_audio_input(**kwargs)

1182 image_input = self._parse_and_validate_image_input(**kwargs)

1183 video_input = self._parse_and_validate_video_input(**kwargs)

vllm/model_executor/models/qwen2_5_vl.py

+1 -1

@@ -1534,7 +1534,7 @@ class Qwen2_5_VLForConditionalGeneration(

1534 def get_language_model(self) -> torch.nn.Module:

1535 return self.language_model

1536

1537 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1537 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1538 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

1539 if not mm_input_by_modality:

1540 return []

vllm/model_executor/models/qwen2_audio.py

+1 -1

@@ -439,7 +439,7 @@ class Qwen2AudioForConditionalGeneration(nn.Module, SupportsMultiModal, Supports

439 def get_language_model(self) -> torch.nn.Module:

440 return self.language_model

441

442 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

442 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

443 audio_input = self._parse_and_validate_audio_input(**kwargs)

444 if audio_input is None:

445 return []

vllm/model_executor/models/qwen2_moe.py

+4 -4

@@ -389,7 +389,7 @@ class Qwen2MoeModel(nn.Module):

389 ["hidden_states", "residual"], config.hidden_size

390 )

391

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

392 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

393 return self.embed_tokens(input_ids)

394

395 def forward(

@@ -403,7 +403,7 @@ class Qwen2MoeModel(nn.Module):

403 if inputs_embeds is not None:

404 hidden_states = inputs_embeds

405 else:

406 - hidden_states = self.get_input_embeddings(input_ids)

406 + hidden_states = self.embed_input_ids(input_ids)

407 residual = None

408 else:

409 assert intermediate_tensors is not None

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

566 self.model.make_empty_intermediate_tensors

567 )

568

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

570 - return self.model.get_input_embeddings(input_ids)

569 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

570 + return self.model.embed_input_ids(input_ids)

571

572 def forward(

573 self,

vllm/model_executor/models/qwen2_rm.py

+2 -2

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

73 self.model.make_empty_intermediate_tensors

74 )

75

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

77 - return self.model.get_input_embeddings(input_ids)

76 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

77 + return self.model.embed_input_ids(input_ids)

78

79 def forward(

80 self,

vllm/model_executor/models/qwen2_vl.py

+1 -1

@@ -1507,7 +1507,7 @@ class Qwen2VLForConditionalGeneration(

1507 def get_language_model(self) -> torch.nn.Module:

1508 return self.language_model

1509

1510 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1510 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1511 modalities = self._parse_and_validate_multimodal_inputs(**kwargs)

1512 if not modalities:

1513 return []

vllm/model_executor/models/qwen3.py

+2 -2

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

306 num_layers = len(self.model.layers)

307 return (2, num_layers // 2, num_layers - 3)

308

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

310 - return self.model.get_input_embeddings(input_ids)

309 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

310 + return self.model.embed_input_ids(input_ids)

311

312 def forward(

313 self,

vllm/model_executor/models/qwen3_moe.py

+4 -4

@@ -427,7 +427,7 @@ class Qwen3MoeModel(nn.Module):

427 # Track layers for auxiliary hidden state outputs (EAGLE3)

428 self.aux_hidden_state_layers: tuple[int, ...] = ()

429

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

430 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

431 return self.embed_tokens(input_ids)

432

433 def forward(

@@ -441,7 +441,7 @@ class Qwen3MoeModel(nn.Module):

441 if inputs_embeds is not None:

442 hidden_states = inputs_embeds

443 else:

444 - hidden_states = self.get_input_embeddings(input_ids)

444 + hidden_states = self.embed_input_ids(input_ids)

445 residual = None

446 else:

447 assert intermediate_tensors is not None

@@ -714,8 +714,8 @@ class Qwen3MoeForCausalLM(

714 num_layers = len(self.model.layers)

715 return (2, num_layers // 2, num_layers - 3)

716

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

718 - return self.model.get_input_embeddings(input_ids)

717 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

718 + return self.model.embed_input_ids(input_ids)

719

720 def forward(

721 self,

vllm/model_executor/models/qwen3_next.py

+4 -4

@@ -998,7 +998,7 @@ class Qwen3NextModel(nn.Module):

998 else:

999 self.norm = PPMissingLayer()

1000

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

1001 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

1002 return self.embed_tokens(input_ids)

1003

1004 def forward(

@@ -1012,7 +1012,7 @@ class Qwen3NextModel(nn.Module):

1012 if inputs_embeds is not None:

1013 hidden_states = inputs_embeds

1014 else:

1015 - hidden_states = self.get_input_embeddings(input_ids)

1015 + hidden_states = self.embed_input_ids(input_ids)

1016 residual = None

1017 else:

1018 assert intermediate_tensors is not None

@@ -1217,8 +1217,8 @@ class Qwen3NextForCausalLM(

1217 # Set MoE hyperparameters

1218 self.set_moe_parameters()

1219

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

1221 - return self.model.get_input_embeddings(input_ids)

1220 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

1221 + return self.model.embed_input_ids(input_ids)

1222

1223 def forward(

1224 self,

vllm/model_executor/models/qwen3_next_mtp.py

+4 -4

@@ -93,7 +93,7 @@ class Qwen3NextMultiTokenPredictor(nn.Module):

93 config.hidden_size, eps=config.rms_norm_eps

94 )

95

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

96 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

97 return self.embed_tokens(input_ids)

98

99 def forward(

@@ -107,7 +107,7 @@ class Qwen3NextMultiTokenPredictor(nn.Module):

107 ) -> torch.Tensor:

108 if get_pp_group().is_first_rank:

109 if inputs_embeds is None:

110 - inputs_embeds = self.get_input_embeddings(input_ids)

110 + inputs_embeds = self.embed_input_ids(input_ids)

111 assert hidden_states.shape[-1] == inputs_embeds.shape[-1]

112 inputs_embeds = self.pre_fc_norm_embedding(inputs_embeds)

113 hidden_states = self.pre_fc_norm_hidden(hidden_states)

@@ -257,8 +257,8 @@ class Qwen3NextMTP(nn.Module, SupportsPP, QwenNextMixtureOfExperts):

257 )

258 self.set_moe_parameters()

259

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

261 - return self.model.get_input_embeddings(input_ids)

260 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

261 + return self.model.embed_input_ids(input_ids)

262

263 def forward(

264 self,

vllm/model_executor/models/qwen3_omni_moe_thinker.py

+5 -7

@@ -613,7 +613,7 @@ class Qwen3MoeLLMModel(Qwen3MoeModel):

613 if inputs_embeds is not None:

614 hidden_states = inputs_embeds

615 else:

616 - hidden_states = self.get_input_embeddings(input_ids)

616 + hidden_states = self.embed_input_ids(input_ids)

617 residual = None

618 else:

619 assert intermediate_tensors is not None

@@ -1252,9 +1252,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(

1252 def get_language_model(self) -> torch.nn.Module:

1253 return self.language_model

1254

1255 - def get_multimodal_embeddings(

1256 - self, **kwargs: object

1257 - ) -> MultiModalEmbeddings | None:

1255 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

1256 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

1257 if not mm_input_by_modality:

1258 return []

@@ -1278,7 +1276,7 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(

1276 multimodal_embeddings += tuple(audio_embeddings)

1277 return multimodal_embeddings

1278

1281 - def get_input_embeddings(

1279 + def embed_input_ids(

1280 self,

1281 input_ids: torch.Tensor,

1282 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1286,9 +1284,9 @@ class Qwen3OmniMoeThinkerForConditionalGeneration(

1284 is_multimodal: torch.Tensor | None = None,

1285 handle_oov_mm_token: bool = False,

1286 ) -> torch.Tensor:

1289 - inputs_embeds = self._get_text_embeddings(

1287 + inputs_embeds = self._embed_text_input_ids(

1288 input_ids,

1291 - self.language_model.get_input_embeddings,

1289 + self.language_model.embed_input_ids,

1290 is_multimodal=is_multimodal,

1291 handle_oov_mm_token=handle_oov_mm_token,

1292 )

vllm/model_executor/models/qwen3_vl.py

+6 -8

@@ -1100,7 +1100,7 @@ class Qwen3LLMModel(Qwen3Model):

1100 if inputs_embeds is not None:

1101 hidden_states = inputs_embeds

1102 else:

1103 - hidden_states = self.get_input_embeddings(input_ids)

1103 + hidden_states = self.embed_input_ids(input_ids)

1104 residual = None

1105 else:

1106 assert intermediate_tensors is not None

@@ -1493,9 +1493,7 @@ class Qwen3VLForConditionalGeneration(

1493 def get_language_model(self) -> torch.nn.Module:

1494 return self.language_model

1495

1496 - def get_multimodal_embeddings(

1497 - self, **kwargs: object

1498 - ) -> MultiModalEmbeddings | None:

1496 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings | None:

1497 mm_input_by_modality = self._parse_and_validate_multimodal_inputs(**kwargs)

1498 if not mm_input_by_modality:

1499 return None

@@ -1557,7 +1555,7 @@ class Qwen3VLForConditionalGeneration(

1555

1556 return deepstack_input_embeds, multimodal_embeddings

1557

1560 - def get_input_embeddings(

1558 + def embed_input_ids(

1559 self,

1560 input_ids: torch.Tensor,

1561 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1565,9 +1563,9 @@ class Qwen3VLForConditionalGeneration(

1563 is_multimodal: torch.Tensor | None = None,

1564 handle_oov_mm_token: bool = False,

1565 ) -> torch.Tensor:

1568 - inputs_embeds = self._get_text_embeddings(

1566 + inputs_embeds = self._embed_text_input_ids(

1567 input_ids,

1570 - self.language_model.get_input_embeddings,

1568 + self.language_model.embed_input_ids,

1569 is_multimodal=is_multimodal,

1570 handle_oov_mm_token=handle_oov_mm_token,

1571 )

@@ -1577,7 +1575,7 @@ class Qwen3VLForConditionalGeneration(

1575

1576 if is_multimodal is None:

1577 raise ValueError(

1580 - "`get_input_embeddings` now requires `is_multimodal` arg, "

1578 + "`embed_input_ids` now requires `is_multimodal` arg, "

1579 "please update your model runner according to "

1580 "https://github.com/vllm-project/vllm/pull/16229."

1581 )

vllm/model_executor/models/qwen3_vl_moe.py

+1 -1

@@ -97,7 +97,7 @@ class Qwen3MoeLLMModel(Qwen3MoeModel):

97 if inputs_embeds is not None:

98 hidden_states = inputs_embeds

99 else:

100 - hidden_states = self.get_input_embeddings(input_ids)

100 + hidden_states = self.embed_input_ids(input_ids)

101 residual = None

102 else:

103 assert intermediate_tensors is not None

vllm/model_executor/models/qwen_vl.py

+1 -1

@@ -777,7 +777,7 @@ class QwenVLForConditionalGeneration(

777 def get_language_model(self) -> torch.nn.Module:

778 return self.transformer

779

780 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

780 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

781 image_input = self._parse_and_validate_image_input(**kwargs)

782 if image_input is None:

783 return []

vllm/model_executor/models/roberta.py

+2 -2

@@ -220,8 +220,8 @@ class RobertaForSequenceClassification(nn.Module, SupportsCrossEncoding):

220 loader = AutoWeightsLoader(self)

221 return loader.load_weights(weights, mapper=self.jina_to_vllm_mapper)

222

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

224 - return self.roberta.get_input_embeddings(input_ids)

223 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

224 + return self.roberta.embed_input_ids(input_ids)

225

226 def forward(

227 self,

vllm/model_executor/models/seed_oss.py

+4 -4

@@ -334,7 +334,7 @@ class SeedOssModel(nn.Module):

334 else:

335 self.norm = PPMissingLayer()

336

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

337 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

338 return self.embed_tokens(input_ids)

339

340 def forward(

@@ -348,7 +348,7 @@ class SeedOssModel(nn.Module):

348 if inputs_embeds is not None:

349 hidden_states = inputs_embeds

350 else:

351 - hidden_states = self.get_input_embeddings(input_ids)

351 + hidden_states = self.embed_input_ids(input_ids)

352 residual = None

353 else:

354 assert intermediate_tensors is not None

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

467 self.model.make_empty_intermediate_tensors

468 )

469

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

471 - return self.model.get_input_embeddings(input_ids)

470 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

471 + return self.model.embed_input_ids(input_ids)

472

473 def forward(

474 self,

vllm/model_executor/models/siglip.py

+5 -5

@@ -595,7 +595,7 @@ class SiglipTextTransformer(nn.Module):

595 self.final_layer_norm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)

596 self.head = nn.Linear(embed_dim, config.projection_size)

597

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

598 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

599 return self.embeddings.token_embedding(input_ids)

600

601 def forward(

@@ -1117,7 +1117,7 @@ class SiglipEmbeddingModel(nn.Module, SupportsMultiModal, SupportsQuant):

1117 def get_language_model(self) -> torch.nn.Module:

1118 return self.text_model

1119

1120 - def get_input_embeddings(

1120 + def embed_input_ids(

1121 self,

1122 input_ids: torch.Tensor,

1123 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1130,16 +1130,16 @@ class SiglipEmbeddingModel(nn.Module, SupportsMultiModal, SupportsQuant):

1130 )

1131

1132 if multimodal_embeddings is None or is_multimodal is None:

1133 - return super().get_input_embeddings(input_ids)

1133 + return super().embed_input_ids(input_ids)

1134

1135 - return super().get_input_embeddings(

1135 + return super().embed_input_ids(

1136 input_ids,

1137 multimodal_embeddings=multimodal_embeddings,

1138 is_multimodal=is_multimodal,

1139 handle_oov_mm_token=handle_oov_mm_token,

1140 )

1141

1142 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

1142 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

1143 image_input = self._parse_and_validate_image_input(**kwargs)

1144 if image_input is None:

1145 return []

vllm/model_executor/models/skyworkr1v.py

+4 -4

@@ -872,14 +872,14 @@ class SkyworkR1VChatModel(nn.Module, SupportsMultiModal, SupportsPP):

872 def get_language_model(self) -> torch.nn.Module:

873 return self.language_model

874

875 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

875 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

876 image_input = self._parse_and_validate_image_input(**kwargs)

877 if image_input is None:

878 return []

879

880 return self._process_image_input(image_input)

881

882 - def get_input_embeddings(

882 + def embed_input_ids(

883 self,

884 input_ids: torch.Tensor,

885 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -892,9 +892,9 @@ class SkyworkR1VChatModel(nn.Module, SupportsMultiModal, SupportsPP):

892

893 # This is to satisfy the type checker for each overload

894 if multimodal_embeddings is None or is_multimodal is None:

895 - return super().get_input_embeddings(input_ids)

895 + return super().embed_input_ids(input_ids)

896

897 - return super().get_input_embeddings(

897 + return super().embed_input_ids(

898 input_ids,

899 multimodal_embeddings=multimodal_embeddings,

900 is_multimodal=is_multimodal,

vllm/model_executor/models/solar.py

+4 -4

@@ -310,7 +310,7 @@ class SolarModel(nn.Module):

310 ["hidden_states", "residual"], config.hidden_size

311 )

312

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

313 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

314 return self.embed_tokens(input_ids)

315

316 def forward(

@@ -324,7 +324,7 @@ class SolarModel(nn.Module):

324 if inputs_embeds is not None:

325 hidden_states = inputs_embeds

326 else:

327 - hidden_states = self.get_input_embeddings(input_ids)

327 + hidden_states = self.embed_input_ids(input_ids)

328 residual = None

329 else:

330 assert intermediate_tensors is not None

@@ -478,8 +478,8 @@ class SolarForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

478 self.model.make_empty_intermediate_tensors

479 )

480

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

482 - return self.model.get_input_embeddings(input_ids)

481 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

482 + return self.model.embed_input_ids(input_ids)

483

484 def forward(

485 self,

vllm/model_executor/models/stablelm.py

+4 -4

@@ -246,7 +246,7 @@ class StableLMEpochModel(nn.Module):

246 ["hidden_states"], config.hidden_size

247 )

248

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

249 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

250 return self.embed_tokens(input_ids)

251

252 def forward(

@@ -260,7 +260,7 @@ class StableLMEpochModel(nn.Module):

260 if inputs_embeds is not None:

261 hidden_states = inputs_embeds

262 else:

263 - hidden_states = self.get_input_embeddings(input_ids)

263 + hidden_states = self.embed_input_ids(input_ids)

264 else:

265 assert intermediate_tensors is not None

266 hidden_states = intermediate_tensors["hidden_states"]

@@ -332,8 +332,8 @@ class StablelmForCausalLM(nn.Module, SupportsPP):

332 self.model.make_empty_intermediate_tensors

333 )

334

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

336 - return self.model.get_input_embeddings(input_ids)

335 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

336 + return self.model.embed_input_ids(input_ids)

337

338 def forward(

339 self,

vllm/model_executor/models/starcoder2.py

+4 -4

@@ -249,7 +249,7 @@ class Starcoder2Model(nn.Module):

249 ["hidden_states"], config.hidden_size

250 )

251

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

252 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

253 return self.embed_tokens(input_ids)

254

255 def forward(

@@ -263,7 +263,7 @@ class Starcoder2Model(nn.Module):

263 if inputs_embeds is not None:

264 hidden_states = inputs_embeds

265 else:

266 - hidden_states = self.get_input_embeddings(input_ids)

266 + hidden_states = self.embed_input_ids(input_ids)

267 else:

268 assert intermediate_tensors is not None

269 hidden_states = intermediate_tensors["hidden_states"]

@@ -333,8 +333,8 @@ class Starcoder2ForCausalLM(nn.Module, SupportsPP):

333 self.model.make_empty_intermediate_tensors

334 )

335

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

337 - return self.model.get_input_embeddings(input_ids)

336 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

337 + return self.model.embed_input_ids(input_ids)

338

339 def forward(

340 self,

vllm/model_executor/models/step3_text.py

+4 -4

@@ -354,7 +354,7 @@ class Step3TextModel(nn.Module):

354 ["hidden_states"], config.hidden_size

355 )

356

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

357 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

358 return self.embed_tokens(input_ids)

359

360 def forward(

@@ -368,7 +368,7 @@ class Step3TextModel(nn.Module):

368 if inputs_embeds is not None:

369 hidden_states = inputs_embeds

370 else:

371 - hidden_states = self.get_input_embeddings(input_ids)

371 + hidden_states = self.embed_input_ids(input_ids)

372 residual = None

373 else:

374 assert intermediate_tensors is not None

@@ -419,8 +419,8 @@ class Step3TextForCausalLM(nn.Module, SupportsPP):

419 self.model.make_empty_intermediate_tensors

420 )

421

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

423 - return self.model.get_input_embeddings(input_ids)

422 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

423 + return self.model.embed_input_ids(input_ids)

424

425 def forward(

426 self,

vllm/model_executor/models/step3_vl.py

+6 -6

@@ -1075,14 +1075,14 @@ class Step3VLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

1075 def get_language_model(self) -> torch.nn.Module:

1076 return self.language_model

1077

1078 - def get_multimodal_embeddings(self, **kwargs) -> MultiModalEmbeddings:

1078 + def embed_multimodal(self, **kwargs) -> MultiModalEmbeddings:

1079 image_input = self._parse_and_validate_image_input(**kwargs)

1080 if image_input is None:

1081 return []

1082 vision_embeddings = self._process_image_input(image_input)

1083 return vision_embeddings

1084

1085 - def get_input_embeddings(

1085 + def embed_input_ids(

1086 self,

1087 input_ids: torch.Tensor,

1088 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -1093,9 +1093,9 @@ class Step3VLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

1093 ) -> torch.Tensor:

1094 # This is to satisfy the type checker for each overload

1095 if multimodal_embeddings is None or is_multimodal is None:

1096 - return super().get_input_embeddings(input_ids)

1096 + return super().embed_input_ids(input_ids)

1097

1098 - return super().get_input_embeddings(

1098 + return super().embed_input_ids(

1099 input_ids,

1100 multimodal_embeddings=multimodal_embeddings,

1101 is_multimodal=is_multimodal,

@@ -1113,8 +1113,8 @@ class Step3VLForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

1113 if intermediate_tensors is not None:

1114 inputs_embeds = None

1115 elif inputs_embeds is None:

1116 - vision_embeddings = self.get_multimodal_embeddings(**kwargs)

1117 - inputs_embeds = self.get_input_embeddings(

1116 + vision_embeddings = self.embed_multimodal(**kwargs)

1117 + inputs_embeds = self.embed_input_ids(

1118 input_ids,

1119 vision_embeddings,

1120 is_multimodal=input_ids == self.config.image_token_id,

vllm/model_executor/models/tarsier.py

+3 -3

@@ -576,7 +576,7 @@ class TarsierForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

576 def get_language_model(self) -> torch.nn.Module:

577 return self.language_model

578

579 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

579 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

580 image_input = self._parse_and_validate_image_input(**kwargs)

581 if image_input is None:

582 return []

@@ -593,8 +593,8 @@ class TarsierForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP)

593 if intermediate_tensors is not None:

594 inputs_embeds = None

595 elif inputs_embeds is None:

596 - vision_embeddings = self.get_multimodal_embeddings(**kwargs)

597 - inputs_embeds = self.get_input_embeddings(

596 + vision_embeddings = self.embed_multimodal(**kwargs)

597 + inputs_embeds = self.embed_input_ids(

598 input_ids,

599 vision_embeddings,

600 is_multimodal=input_ids == self.config.image_token_index,

vllm/model_executor/models/teleflm.py

+1 -1

@@ -57,7 +57,7 @@ class TeleFLMModel(LlamaModel):

57 if self.use_mup:

58 self.input_mult = self.config.input_mult

59

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

60 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

61 embedding = self.embed_tokens(input_ids)

62 if self.use_mup:

63 embedding = embedding * self.input_mult

vllm/model_executor/models/terratorch.py

+1 -1

@@ -251,7 +251,7 @@ class Terratorch(nn.Module, IsAttentionFree, SupportsMultiModal):

251

252 self.pooler = DispatchPooler({"plugin": DummyPooler()})

253

254 - def get_input_embeddings(

254 + def embed_input_ids(

255 self,

256 input_ids: torch.Tensor,

257 multimodal_embeddings: MultiModalEmbeddings | None = None,

vllm/model_executor/models/transformers/base.py

+2 -2

@@ -385,7 +385,7 @@ class Base(nn.Module, VllmModel, SupportsQuant, SupportsLoRA, SupportsPP):

385

386 _init_parameters(module, dtype)

387

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

388 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

389 inputs_embeds = self.model.get_input_embeddings()(input_ids)

390 if self.embed_scale is not None:

391 inputs_embeds *= self.embed_scale

@@ -416,7 +416,7 @@ class Base(nn.Module, VllmModel, SupportsQuant, SupportsLoRA, SupportsPP):

416 and input_ids is not None

417 and inputs_embeds is None

418 ):

419 - inputs_embeds = self.get_input_embeddings(input_ids)

419 + inputs_embeds = self.embed_input_ids(input_ids)

420 input_ids = None

421

422 if self.model_config.uses_mrope:

vllm/model_executor/models/transformers/multimodal.py

+1 -1

@@ -330,7 +330,7 @@ class MultiModalMixin(SupportsMultiModal, SupportsMRoPE):

330

331 return LanguageModel(self)

332

333 - def get_multimodal_embeddings(self, **kwargs):

333 + def embed_multimodal(self, **kwargs):

334 pixel_values: torch.Tensor | None = kwargs.pop("pixel_values", None)

335 image_embeds: torch.Tensor | None = kwargs.pop("image_embeds", None)

336 # Model might use `image_patches` instead of `pixel_values`

vllm/model_executor/models/ultravox.py

+4 -4

@@ -579,14 +579,14 @@ class UltravoxModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA):

579 def get_language_model(self) -> torch.nn.Module:

580 return self.language_model

581

582 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

582 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

583 audio_input = self._parse_and_validate_audio_input(**kwargs)

584 if audio_input is None:

585 return []

586 audio_embeddings = self._process_audio_input(audio_input)

587 return audio_embeddings

588

589 - def get_input_embeddings(

589 + def embed_input_ids(

590 self,

591 input_ids: torch.Tensor,

592 multimodal_embeddings: MultiModalEmbeddings | None = None,

@@ -597,9 +597,9 @@ class UltravoxModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA):

597 ) -> torch.Tensor:

598 # This is to satisfy the type checker for each overload

599 if multimodal_embeddings is None or is_multimodal is None:

600 - return super().get_input_embeddings(input_ids)

600 + return super().embed_input_ids(input_ids)

601

602 - return super().get_input_embeddings(

602 + return super().embed_input_ids(

603 input_ids,

604 multimodal_embeddings=multimodal_embeddings,

605 is_multimodal=is_multimodal,

vllm/model_executor/models/utils.py

+1 -1

@@ -474,7 +474,7 @@ def _merge_multimodal_embeddings(

474

475 @deprecated(

476 "`merge_multimodal_embeddings` has been replaced with "

477 - "`SupportsMultiModal.get_input_embeddings` and will be "

477 + "`SupportsMultiModal.embed_input_ids` and will be "

478 "removed in v0.12."

479 )

480 def merge_multimodal_embeddings(

vllm/model_executor/models/voxtral.py

+1 -1

@@ -399,7 +399,7 @@ class VoxtralForConditionalGeneration(

399

400 return hidden_states

401

402 - def get_multimodal_embeddings(

402 + def embed_multimodal(

403 self, **kwargs

404 ) -> list[torch.Tensor] | torch.Tensor | tuple[torch.Tensor, ...] | None:

405 audio_inputs = self._parse_and_validate_audio_arrays(**kwargs)

vllm/model_executor/models/whisper.py

+5 -5

@@ -570,7 +570,7 @@ class WhisperDecoder(nn.Module):

570 positions: torch.Tensor,

571 encoder_hidden_states: torch.Tensor | None,

572 ):

573 - inputs_embeds = self.get_input_embeddings(input_ids)

573 + inputs_embeds = self.embed_input_ids(input_ids)

574 positions = self.embed_positions(positions)

575 hidden_states = inputs_embeds + positions

576

@@ -583,7 +583,7 @@ class WhisperDecoder(nn.Module):

583 hidden_states = self.layer_norm(hidden_states)

584 return hidden_states

585

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

586 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

587 return self.embed_tokens(input_ids)

588

589

@@ -907,12 +907,12 @@ class WhisperForConditionalGeneration(

907 def get_language_model(self) -> torch.nn.Module:

908 return self.model.decoder

909

910 - def get_multimodal_embeddings(self, **kwargs: object) -> MultiModalEmbeddings:

910 + def embed_multimodal(self, **kwargs: object) -> MultiModalEmbeddings:

911 # Required as part of SupportsMultiModal interface.

912 audio_input = self._parse_and_validate_audio_input(**kwargs)

913 return [self.model.get_encoder_outputs(audio_input["input_features"])]

914

915 - def get_input_embeddings(

915 + def embed_input_ids(

916 self,

917 input_ids: torch.Tensor,

918 multimodal_embeddings: MultiModalEmbeddings | None = None,

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

922 ) -> torch.Tensor:

923 # This method just returns the decoder sequence embeddings since

924 # Whisper does not have encoder text tokens.

925 - return self.model.decoder.get_input_embeddings(input_ids)

925 + return self.model.decoder.embed_input_ids(input_ids)

926

927 def _parse_and_validate_audio_input(self, **kwargs: object) -> WhisperAudioInputs:

928 input_features = kwargs.pop("input_features", None)

vllm/model_executor/models/zamba2.py

+4 -4

@@ -756,7 +756,7 @@ class Zamba2Model(nn.Module):

756 # Final layer normalization

757 self.final_layernorm = RMSNorm(config.hidden_size, eps=config.rms_norm_eps)

758

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

759 + def embed_input_ids(self, input_ids: torch.Tensor) -> torch.Tensor:

760 """Convert input token IDs to embeddings.

761

762 Args:

@@ -786,7 +786,7 @@ class Zamba2Model(nn.Module):

786 """

787 # Handle pipeline parallelism for first rank

788 if inputs_embeds is None:

789 - inputs_embeds = self.get_input_embeddings(input_ids)

789 + inputs_embeds = self.embed_input_ids(input_ids)

790 hidden_states = inputs_embeds

791

792 # Process through layers

@@ -930,14 +930,14 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsMambaPrefixC

930 # Initialize logits processing and sampling

931 self.logits_processor = LogitsProcessor(config.vocab_size)

932

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

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

934 """Convert input token IDs to embeddings.

935 Args:

936 input_ids: Tensor of input token IDs

937 Returns:

938 Embedded representation of the input tokens

939 """

940 - return self.model.get_input_embeddings(input_ids)

940 + return self.model.embed_input_ids(input_ids)

941

942 def forward(

943 self,

vllm/multimodal/processing.py

+1 -1

@@ -208,7 +208,7 @@ class PromptUpdateDetails(Generic[_S]):

208 `None` (default) means to assign embeddings to all positions of `full`.

209

210 The embeddings are obtained by calling

211 - [`SupportsMultiModal.get_multimodal_embeddings`][vllm.model_executor.models.interfaces.SupportsMultiModal.get_multimodal_embeddings].

211 + [`SupportsMultiModal.embed_multimodal`][vllm.model_executor.models.interfaces.SupportsMultiModal.embed_multimodal].

212 """

213

214 @staticmethod

vllm/v1/spec_decode/eagle.py

+3 -7

@@ -279,7 +279,7 @@ class EagleProposer:

279 if self.supports_mm_inputs:

280 mm_embeds, is_mm_embed = mm_embed_inputs or (None, None)

281

282 - self.inputs_embeds[:num_tokens] = self.model.get_input_embeddings(

282 + self.inputs_embeds[:num_tokens] = self.model.embed_input_ids(

283 self.input_ids[:num_tokens],

284 multimodal_embeddings=mm_embeds,

285 is_multimodal=is_mm_embed,

@@ -447,9 +447,7 @@ class EagleProposer:

447 self._set_positions(batch_size, clamped_positions)

448 self.hidden_states[:batch_size] = hidden_states

449 if self.supports_mm_inputs:

450 - self.inputs_embeds[:batch_size] = self.model.get_input_embeddings(

451 - input_ids

452 - )

450 + self.inputs_embeds[:batch_size] = self.model.embed_input_ids(input_ids)

451

452 input_ids = None

453 inputs_embeds = self.inputs_embeds[:input_batch_size]

@@ -972,9 +970,7 @@ class EagleProposer:

970 # text-only draft models

971 try:

972 dummy_input_ids = torch.tensor([[1]], device=self.input_ids.device)

975 - self.model.get_input_embeddings(

976 - dummy_input_ids, multimodal_embeddings=None

977 - )

973 + self.model.embed_input_ids(dummy_input_ids, multimodal_embeddings=None)

974 except (NotImplementedError, AttributeError, TypeError):

975 logger.warning(

976 "Draft model does not support multimodal inputs, "

vllm/v1/worker/gpu_model_runner.py

+5 -5

@@ -1853,7 +1853,7 @@ class GPUModelRunner(

1853 )

1854 )

1855

1856 - micro_batch_outputs = model.get_multimodal_embeddings(

1856 + micro_batch_outputs = model.embed_multimodal(

1857 **micro_batch_mm_inputs

1858 )

1859

@@ -1866,7 +1866,7 @@ class GPUModelRunner(

1866 # 2. A list or tuple (length: num_items) of tensors,

1867 # each of shape (feature_size, hidden_size) in case the feature

1868 # size is dynamic depending on the input multimodal items.

1869 - curr_group_outputs = model.get_multimodal_embeddings(**mm_kwargs_group)

1869 + curr_group_outputs = model.embed_multimodal(**mm_kwargs_group)

1870

1871 sanity_check_mm_encoder_outputs(

1872 curr_group_outputs,

@@ -2225,7 +2225,7 @@ class GPUModelRunner(

2225 # NOTE(woosuk): To unify token ids and soft tokens (vision

2226 # embeddings), we always use embeddings (rather than token ids)

2227 # as input to the multimodal model, even when the input is text.

2228 - inputs_embeds_scheduled = self.model.get_input_embeddings(

2228 + inputs_embeds_scheduled = self.model.embed_input_ids(

2229 self.input_ids.gpu[:num_scheduled_tokens],

2230 multimodal_embeddings=mm_embeds,

2231 is_multimodal=is_mm_embed,

@@ -2261,7 +2261,7 @@ class GPUModelRunner(

2261 # Some tokens ids may need to become embeds

2262 if token_ids_idx.numel() > 0:

2263 token_ids = self.input_ids.gpu[token_ids_idx]

2264 - tokens_to_embeds = self.model.get_input_embeddings(input_ids=token_ids)

2264 + tokens_to_embeds = self.model.embed_input_ids(input_ids=token_ids)

2265 self.inputs_embeds.gpu[token_ids_idx] = tokens_to_embeds

2266

2267 inputs_embeds = self.inputs_embeds.gpu[:num_input_tokens]

@@ -3889,7 +3889,7 @@ class GPUModelRunner(

3889 )

3890

3891 # Run multimodal encoder.

3892 - dummy_encoder_outputs = self.model.get_multimodal_embeddings(

3892 + dummy_encoder_outputs = self.model.embed_multimodal(

3893 **batched_dummy_mm_inputs

3894 )

3895

vllm/v1/worker/tpu_model_runner.py

+10 -12

@@ -962,7 +962,7 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

962 # (feature_size, hidden_size) in case the feature size is dynamic

963 # depending on the input multimodal items.

964 torch_xla.sync(wait=False)

965 - curr_group_outputs = model.get_multimodal_embeddings(**mm_kwargs_group)

965 + curr_group_outputs = model.embed_multimodal(**mm_kwargs_group)

966 torch_xla.sync(wait=False)

967

968 sanity_check_mm_encoder_outputs(

@@ -1065,7 +1065,7 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1065 # NOTE(woosuk): To unify token ids and soft tokens (vision

1066 # embeddings), we always use embeddings (rather than token ids)

1067 # as input to the multimodal model, even when the input is text.

1068 - inputs_embeds = self.model.get_input_embeddings(

1068 + inputs_embeds = self.model.embed_input_ids(

1069 input_ids,

1070 multimodal_embeddings=mm_embeds,

1071 is_multimodal=is_mm_embed,

@@ -1484,14 +1484,12 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1484 )

1485 # Run multimodal encoder.

1486 torch_xla.sync(wait=False)

1487 - mm_embeds = self.model.get_multimodal_embeddings(

1488 - **batched_dummy_mm_inputs

1489 - )

1487 + mm_embeds = self.model.embed_multimodal(**batched_dummy_mm_inputs)

1488 torch_xla.sync(wait=False)

1489 num_patches = mm_embeds[0].shape[0]

1490 items_size = num_patches * num_items

1491

1494 - # NOTE (NickLucche) pre-compile `get_input_embeddings` when mm

1492 + # NOTE (NickLucche) pre-compile `embed_input_ids` when mm

1493 # embeddings are present. We assume `--disable-mm-chunked`,

1494 # hence only whole items can be scheduled. This implies we just

1495 # need to compile when `num_items` fit the (padded) `input_ids`

@@ -1519,7 +1517,7 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1517 assert a is None

1518 torch_xla.sync(wait=False)

1519

1522 - # Pre-compile `get_input_embeddings` when mm_embeddings are not

1520 + # Pre-compile `embed_input_ids` when mm_embeddings are not

1521 # present. Chunk is only made of text, no mm_placeholders.

1522 for num_tokens in self.num_tokens_paddings:

1523 placeholders_ids = torch.zeros(

@@ -1738,7 +1736,7 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1736 # impact of recompilation until it's fixed.

1737 start = time.perf_counter()

1738 torch_xla.sync(wait=False)

1741 - dummy_encoder_outputs = self.model.get_multimodal_embeddings(

1739 + dummy_encoder_outputs = self.model.embed_multimodal(

1740 **batched_dummy_mm_inputs

1741 )

1742 torch_xla.sync(wait=False)

@@ -1974,11 +1972,11 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1972 )

1973 return logits_cloned

1974

1977 - def get_multimodal_embeddings(self, *args, **kwargs):

1978 - return self.model.get_multimodal_embeddings(*args, **kwargs)

1975 + def embed_multimodal(self, *args, **kwargs):

1976 + return self.model.embed_multimodal(*args, **kwargs)

1977

1980 - def get_input_embeddings(self, *args, **kwargs):

1981 - return self.model.get_input_embeddings(*args, **kwargs)

1978 + def embed_input_ids(self, *args, **kwargs):

1979 + return self.model.embed_input_ids(*args, **kwargs)

1980

1981 def prepare_structured_decoding_input(

1982 self, logits: torch.Tensor, grammar_output: "GrammarOutput"

vllm/v1/worker/utils.py

+4 -4

@@ -177,27 +177,27 @@ def sanity_check_mm_encoder_outputs(

177 ) -> None:

178 """

179 Perform sanity checks for the result of

180 - [`vllm.model_executor.models.SupportsMultiModal.get_multimodal_embeddings`][].

180 + [`vllm.model_executor.models.SupportsMultiModal.embed_multimodal`][].

181 """

182 assert isinstance(mm_embeddings, (list, tuple, torch.Tensor)), (

183 "Expected multimodal embeddings to be a list/tuple of 2D tensors, "

184 f"or a single 3D tensor, but got {type(mm_embeddings)} "

185 "instead. This is most likely due to incorrect implementation "

186 - "of the model's `get_multimodal_embeddings` method."

186 + "of the model's `embed_multimodal` method."

187 )

188

189 assert len(mm_embeddings) == expected_num_items, (

190 "Expected number of multimodal embeddings to match number of "

191 f"input items: {expected_num_items}, but got {len(mm_embeddings)=} "

192 "instead. This is most likely due to incorrect implementation "

193 - "of the model's `get_multimodal_embeddings` method."

193 + "of the model's `embed_multimodal` method."

194 )

195

196 assert all(e.ndim == 2 for e in mm_embeddings), (

197 "Expected multimodal embeddings to be a sequence of 2D tensors, "

198 f"but got tensors with shapes {[e.shape for e in mm_embeddings]} "

199 "instead. This is most likely due to incorrect implementation "

200 - "of the model's `get_multimodal_embeddings` method."

200 + "of the model's `embed_multimodal` method."

201 )

202

203

Rename clashing method names for vLLM model protocol (#27583)