[V0 Deprecation] Remove V0 sampling metadata (#25345)

tests/plugins/vllm_add_dummy_model/vllm_add_dummy_model/my_llava.py

+3 -5

@@ -9,7 +9,6 @@ from vllm.model_executor.models.llava import (LlavaDummyInputsBuilder,

9 LlavaForConditionalGeneration,

10 LlavaMultiModalProcessor,

11 LlavaProcessingInfo)

12 -from vllm.model_executor.sampling_metadata import SamplingMetadata

12 from vllm.multimodal import MULTIMODAL_REGISTRY

13

14

@@ -18,11 +17,10 @@ from vllm.multimodal import MULTIMODAL_REGISTRY

17 dummy_inputs=LlavaDummyInputsBuilder)

18 class MyLlava(LlavaForConditionalGeneration):

19

21 - def compute_logits(

22 - self, hidden_states: torch.Tensor,

23 - sampling_metadata: SamplingMetadata) -> Optional[torch.Tensor]:

20 + def compute_logits(self,

21 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

22 # this dummy model always predicts the first token

25 - logits = super().compute_logits(hidden_states, sampling_metadata)

23 + logits = super().compute_logits(hidden_states)

24 if logits is not None:

25 logits.zero_()

26 logits[:, 0] += 1.0

tests/plugins/vllm_add_dummy_model/vllm_add_dummy_model/my_opt.py

+3 -5

@@ -6,16 +6,14 @@ from typing import Optional

6 import torch

7

8 from vllm.model_executor.models.opt import OPTForCausalLM

9 -from vllm.model_executor.sampling_metadata import SamplingMetadata

9

10

11 class MyOPTForCausalLM(OPTForCausalLM):

12

14 - def compute_logits(

15 - self, hidden_states: torch.Tensor,

16 - sampling_metadata: SamplingMetadata) -> Optional[torch.Tensor]:

13 + def compute_logits(self,

14 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

15 # this dummy model always predicts the first token

18 - logits = super().compute_logits(hidden_states, sampling_metadata)

16 + logits = super().compute_logits(hidden_states)

17 if logits is not None:

18 logits.zero_()

19 logits[:, 0] += 1.0

vllm/model_executor/__init__.py

-2

@@ -3,11 +3,9 @@

3

4 from vllm.model_executor.parameter import (BasevLLMParameter,

5 PackedvLLMParameter)

6 -from vllm.model_executor.sampling_metadata import SamplingMetadata

6 from vllm.model_executor.utils import set_random_seed

7

8 __all__ = [

10 - "SamplingMetadata",

9 "set_random_seed",

10 "BasevLLMParameter",

11 "PackedvLLMParameter",

vllm/model_executor/layers/logits_processor.py

-2

@@ -10,7 +10,6 @@ from vllm.distributed import (tensor_model_parallel_all_gather,

10 from vllm.model_executor.custom_op import CustomOp

11 from vllm.model_executor.layers.vocab_parallel_embedding import (

12 VocabParallelEmbedding)

13 -from vllm.model_executor.sampling_metadata import SamplingMetadata

13 from vllm.platforms import current_platform

14

15

@@ -50,7 +49,6 @@ class LogitsProcessor(CustomOp):

49 self,

50 lm_head: VocabParallelEmbedding,

51 hidden_states: torch.Tensor,

53 - sampling_metadata: Optional[SamplingMetadata] = None,

52 embedding_bias: Optional[torch.Tensor] = None,

53 ) -> Optional[torch.Tensor]:

54 if self.logits_as_input:

vllm/model_executor/models/apertus.py

+1 -4

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

48 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

49 from vllm.model_executor.model_loader.weight_utils import (

50 default_weight_loader, maybe_remap_kv_scale_name)

51 -from vllm.model_executor.sampling_metadata import SamplingMetadata

51 from vllm.sequence import IntermediateTensors

52

53 from .interfaces import SupportsLoRA, SupportsPP

@@ -566,10 +565,8 @@ class ApertusForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

565 def compute_logits(

566 self,

567 hidden_states: torch.Tensor,

569 - sampling_metadata: SamplingMetadata,

568 ) -> Optional[torch.Tensor]:

571 - logits = self.logits_processor(self.lm_head, hidden_states,

572 - sampling_metadata)

569 + logits = self.logits_processor(self.lm_head, hidden_states)

570 return logits

571

572 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/arcee.py

+3 -4

@@ -399,11 +399,10 @@ class ArceeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

399 inputs_embeds=inputs_embeds)

400 return model_output

401

402 - def compute_logits(self, hidden_states: torch.Tensor,

403 - sampling_metadata) -> Optional[torch.Tensor]:

402 + def compute_logits(self,

403 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

404 # Compute final logits from hidden states (last pipeline rank only)

405 - logits = self.logits_processor(self.lm_head, hidden_states,

406 - sampling_metadata)

405 + logits = self.logits_processor(self.lm_head, hidden_states)

406 return logits

407

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

vllm/model_executor/models/arctic.py

+1 -4

@@ -30,7 +30,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

30 from vllm.model_executor.layers.vocab_parallel_embedding import (

31 ParallelLMHead, VocabParallelEmbedding)

32 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

33 -from vllm.model_executor.sampling_metadata import SamplingMetadata

33 from vllm.model_executor.utils import set_weight_attrs

34 from vllm.platforms import current_platform

35 from vllm.sequence import IntermediateTensors

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

455 def compute_logits(

456 self,

457 hidden_states: torch.Tensor,

459 - sampling_metadata: SamplingMetadata,

458 ) -> Optional[torch.Tensor]:

461 - logits = self.logits_processor(self.lm_head, hidden_states,

462 - sampling_metadata)

459 + logits = self.logits_processor(self.lm_head, hidden_states)

460 return logits

461

462 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/aria.py

+2 -5

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

19 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

20 from vllm.model_executor.model_loader.weight_utils import (

21 default_weight_loader, maybe_remap_kv_scale_name)

22 -from vllm.model_executor.sampling_metadata import SamplingMetadata

22 from vllm.multimodal import MULTIMODAL_REGISTRY

23 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

24 MultiModalKwargsItems)

@@ -644,10 +643,8 @@ class AriaForConditionalGeneration(nn.Module, SupportsMultiModal):

643

644 return hidden_states

645

647 - def compute_logits(self, hidden_states: torch.Tensor,

648 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

649 - logits = self.logits_processor(self.lm_head, hidden_states,

650 - sampling_metadata)

646 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

647 + logits = self.logits_processor(self.lm_head, hidden_states)

648 return logits

649

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

vllm/model_executor/models/aya_vision.py

+1 -4

@@ -16,7 +16,6 @@ from transformers.models.got_ocr2.image_processing_got_ocr2 import (

16 get_optimal_tiled_canvas)

17

18 from vllm.config import VllmConfig

19 -from vllm.model_executor.sampling_metadata import SamplingMetadata

19 from vllm.multimodal import MULTIMODAL_REGISTRY

20 from vllm.multimodal.inputs import MultiModalDataDict, MultiModalKwargsItems

21 from vllm.multimodal.parse import (ImageProcessorItems, ImageSize,

@@ -464,7 +463,5 @@ class AyaVisionForConditionalGeneration(nn.Module, SupportsMultiModal,

463 def compute_logits(

464 self,

465 hidden_states: torch.Tensor,

467 - sampling_metadata: SamplingMetadata,

466 ) -> Optional[torch.Tensor]:

469 - return self.language_model.compute_logits(hidden_states,

470 - sampling_metadata)

467 + return self.language_model.compute_logits(hidden_states)

vllm/model_executor/models/baichuan.py

+1 -4

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

46 ParallelLMHead, VocabParallelEmbedding)

47 from vllm.model_executor.model_loader.weight_utils import (

48 default_weight_loader, row_parallel_weight_loader)

49 -from vllm.model_executor.sampling_metadata import SamplingMetadata

49 from vllm.sequence import IntermediateTensors

50

51 from .interfaces import SupportsLoRA, SupportsPP, SupportsQuant

@@ -421,10 +420,8 @@ class BaiChuanBaseForCausalLM(nn.Module, SupportsLoRA, SupportsPP,

420 def compute_logits(

421 self,

422 hidden_states: torch.Tensor,

424 - sampling_metadata: SamplingMetadata,

423 ) -> Optional[torch.Tensor]:

426 - logits = self.logits_processor(self.lm_head, hidden_states,

427 - sampling_metadata)

424 + logits = self.logits_processor(self.lm_head, hidden_states)

425 return logits

426

427 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/bailing_moe.py

+1 -4

@@ -51,7 +51,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

51 from vllm.model_executor.layers.vocab_parallel_embedding import (

52 ParallelLMHead, VocabParallelEmbedding)

53 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

54 -from vllm.model_executor.sampling_metadata import SamplingMetadata

54 from vllm.sequence import IntermediateTensors

55

56 from .interfaces import SupportsLoRA, SupportsPP

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

622 def compute_logits(

623 self,

624 hidden_states: torch.Tensor,

626 - sampling_metadata: SamplingMetadata,

625 ) -> Optional[torch.Tensor]:

628 - logits = self.logits_processor(self.lm_head, hidden_states,

629 - sampling_metadata)

626 + logits = self.logits_processor(self.lm_head, hidden_states)

627 return logits

628

629 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/bamba.py

+1 -4

@@ -34,7 +34,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

34 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

35 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

36 MambaCacheParams)

37 -from vllm.model_executor.sampling_metadata import SamplingMetadata

37 from vllm.sequence import IntermediateTensors

38 from vllm.utils import LayerBlockType

39

@@ -571,10 +570,8 @@ class BambaForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

570 def compute_logits(

571 self,

572 hidden_states: torch.Tensor,

574 - sampling_metadata: SamplingMetadata,

573 ) -> Optional[torch.Tensor]:

576 - logits = self.logits_processor(self.lm_head, hidden_states,

577 - sampling_metadata)

574 + logits = self.logits_processor(self.lm_head, hidden_states)

575 return logits

576

577 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/blip2.py

+1 -4

@@ -12,7 +12,6 @@ from transformers import (BatchFeature, Blip2Config, Blip2QFormerConfig,

12 from vllm.config import CacheConfig, VllmConfig

13 from vllm.model_executor.layers.activation import get_act_fn

14 from vllm.model_executor.layers.quantization import QuantizationConfig

15 -from vllm.model_executor.sampling_metadata import SamplingMetadata

15 from vllm.multimodal import MULTIMODAL_REGISTRY

16 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

17 MultiModalKwargsItems)

@@ -704,10 +703,8 @@ class Blip2ForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP,

703 def compute_logits(

704 self,

705 hidden_states: torch.Tensor,

707 - sampling_metadata: SamplingMetadata,

706 ) -> Optional[torch.Tensor]:

709 - return self.language_model.compute_logits(hidden_states,

710 - sampling_metadata)

707 + return self.language_model.compute_logits(hidden_states)

708

709 def load_weights(self, weights: Iterable[tuple[str,

710 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/bloom.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 ParallelLMHead, VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsPP, SupportsQuant

@@ -355,10 +354,8 @@ class BloomForCausalLM(nn.Module, SupportsPP, SupportsQuant):

354 def compute_logits(

355 self,

356 hidden_states: torch.Tensor,

358 - sampling_metadata: SamplingMetadata,

357 ) -> Optional[torch.Tensor]:

360 - logits = self.logits_processor(self.lm_head, hidden_states,

361 - sampling_metadata)

358 + logits = self.logits_processor(self.lm_head, hidden_states)

359 return logits

360

361 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/chameleon.py

+1 -4

@@ -28,7 +28,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

28 ParallelLMHead, VocabParallelEmbedding)

29 from vllm.model_executor.model_loader.weight_utils import (

30 default_weight_loader, row_parallel_weight_loader)

31 -from vllm.model_executor.sampling_metadata import SamplingMetadata

31 from vllm.model_executor.utils import set_weight_attrs

32 from vllm.multimodal import MULTIMODAL_REGISTRY

33 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -1046,10 +1045,8 @@ class ChameleonForConditionalGeneration(nn.Module, SupportsMultiModal,

1045 def compute_logits(

1046 self,

1047 hidden_states: torch.Tensor,

1049 - sampling_metadata: SamplingMetadata,

1048 ) -> Optional[torch.Tensor]:

1051 - logits = self.logits_processor(self.lm_head, hidden_states,

1052 - sampling_metadata)

1049 + logits = self.logits_processor(self.lm_head, hidden_states)

1050

1051 # Disallow image tokens which does not include special

1052 # begin-image and end-image tokens

vllm/model_executor/models/chatglm.py

+1 -4

@@ -27,7 +27,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

27 from vllm.model_executor.layers.vocab_parallel_embedding import (

28 ParallelLMHead, VocabParallelEmbedding)

29 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

30 -from vllm.model_executor.sampling_metadata import SamplingMetadata

30 from vllm.sequence import IntermediateTensors

31 from vllm.transformers_utils.configs import ChatGLMConfig

32

@@ -437,10 +436,8 @@ class ChatGLMBaseModel(nn.Module):

436 def compute_logits(

437 self,

438 hidden_states: torch.Tensor,

440 - sampling_metadata: SamplingMetadata,

439 ) -> Optional[torch.Tensor]:

442 - logits = self.logits_processor(self.lm_head, hidden_states,

443 - sampling_metadata)

440 + logits = self.logits_processor(self.lm_head, hidden_states)

441 return logits

442

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

vllm/model_executor/models/cohere2_vision.py

+1 -4

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

21 RowParallelLinear)

22 from vllm.model_executor.layers.quantization import QuantizationConfig

23 from vllm.model_executor.layers.quantization.awq import AWQConfig

24 -from vllm.model_executor.sampling_metadata import SamplingMetadata

24 from vllm.multimodal import MULTIMODAL_REGISTRY

25 from vllm.multimodal.inputs import MultiModalDataDict, MultiModalKwargsItems

26 from vllm.multimodal.parse import (ImageProcessorItems, ImageSize,

@@ -478,7 +477,5 @@ class Cohere2VisionForConditionalGeneration(nn.Module, SupportsMultiModal,

477 def compute_logits(

478 self,

479 hidden_states: torch.Tensor,

481 - sampling_metadata: SamplingMetadata,

480 ) -> Optional[torch.Tensor]:

483 - return self.language_model.compute_logits(hidden_states,

484 - sampling_metadata)

481 + return self.language_model.compute_logits(hidden_states)

vllm/model_executor/models/commandr.py

+2 -4

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

46 from vllm.model_executor.model_loader.weight_utils import (

47 default_weight_loader, maybe_remap_kv_scale_name,

48 row_parallel_weight_loader)

49 -from vllm.model_executor.sampling_metadata import SamplingMetadata

49 from vllm.model_executor.utils import set_weight_attrs

50 from vllm.platforms import current_platform

51 from vllm.sequence import IntermediateTensors

@@ -448,15 +447,14 @@ class CohereForCausalLM(nn.Module, SupportsLoRA, SupportsPP, SupportsQuant):

447 def compute_logits(

448 self,

449 hidden_states: torch.Tensor,

451 - sampling_metadata: SamplingMetadata,

450 ) -> Optional[torch.Tensor]:

451 is_not_lora = hasattr(self.model.embed_tokens, 'weight')

452 if is_not_lora:

453 logits = self.logits_processor(self.model.embed_tokens,

456 - hidden_states, sampling_metadata)

454 + hidden_states)

455 else:

456 logits = self.logits_processor(self.model.embed_tokens.base_layer,

459 - hidden_states, sampling_metadata)

457 + hidden_states)

458

459 return logits

460

vllm/model_executor/models/dbrx.py

+1 -4

@@ -24,7 +24,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

24 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

25 from vllm.model_executor.model_loader.weight_utils import (

26 default_weight_loader, maybe_remap_kv_scale_name)

27 -from vllm.model_executor.sampling_metadata import SamplingMetadata

27 from vllm.sequence import IntermediateTensors

28

29 from .interfaces import SupportsPP

@@ -462,10 +461,8 @@ class DbrxForCausalLM(nn.Module, SupportsPP):

461 def compute_logits(

462 self,

463 hidden_states: torch.Tensor,

465 - sampling_metadata: SamplingMetadata,

464 ) -> Optional[torch.Tensor]:

467 - logits = self.logits_processor(self.lm_head, hidden_states,

468 - sampling_metadata)

465 + logits = self.logits_processor(self.lm_head, hidden_states)

466 return logits

467

468 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/deepseek.py

+1 -4

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

49 from vllm.model_executor.layers.vocab_parallel_embedding import (

50 ParallelLMHead, VocabParallelEmbedding)

51 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

52 -from vllm.model_executor.sampling_metadata import SamplingMetadata

52 from vllm.sequence import IntermediateTensors

53

54 from .interfaces import SupportsLoRA, SupportsPP

@@ -488,10 +487,8 @@ class DeepseekForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

487 def compute_logits(

488 self,

489 hidden_states: torch.Tensor,

491 - sampling_metadata: SamplingMetadata,

490 ) -> Optional[torch.Tensor]:

493 - logits = self.logits_processor(self.lm_head, hidden_states,

494 - sampling_metadata)

491 + logits = self.logits_processor(self.lm_head, hidden_states)

492 return logits

493

494 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/deepseek_eagle.py

+1 -4

@@ -19,7 +19,6 @@ from vllm.model_executor.model_loader.weight_utils import (

19 default_weight_loader, maybe_remap_kv_scale_name)

20 from vllm.model_executor.models.deepseek_v2 import (DeepseekV2DecoderLayer,

21 DeepseekV3ForCausalLM)

22 -from vllm.model_executor.sampling_metadata import SamplingMetadata

22

23 from .utils import AutoWeightsLoader, maybe_prefix

24

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

221 def compute_logits(

222 self,

223 hidden_states: torch.Tensor,

225 - sampling_metadata: SamplingMetadata,

224 ) -> Optional[torch.Tensor]:

227 - logits = self.logits_processor(self.lm_head, hidden_states,

228 - sampling_metadata)

225 + logits = self.logits_processor(self.lm_head, hidden_states)

226 return logits

227

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

vllm/model_executor/models/deepseek_mtp.py

+2 -7

@@ -15,7 +15,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

15 from vllm.model_executor.layers.vocab_parallel_embedding import (

16 ParallelLMHead, VocabParallelEmbedding)

17 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

18 -from vllm.model_executor.sampling_metadata import SamplingMetadata

18 from vllm.sequence import IntermediateTensors

19

20 from .deepseek_v2 import (DeepseekV2DecoderLayer,

@@ -124,15 +123,13 @@ class DeepSeekMultiTokenPredictor(nn.Module):

123 def compute_logits(

124 self,

125 hidden_states: torch.Tensor,

127 - sampling_metadata: SamplingMetadata,

126 spec_step_idx: int = 0,

127 ) -> torch.Tensor:

128 current_step_idx = (spec_step_idx % self.num_mtp_layers)

129 mtp_layer = self.layers[str(self.mtp_start_layer_idx +

130 current_step_idx)]

131 logits = self.logits_processor(mtp_layer.shared_head.head,

134 - mtp_layer.shared_head(hidden_states),

135 - sampling_metadata)

132 + mtp_layer.shared_head(hidden_states))

133 return logits

134

135

@@ -161,11 +158,9 @@ class DeepSeekMTP(nn.Module, SupportsPP):

158 def compute_logits(

159 self,

160 hidden_states: torch.Tensor,

164 - sampling_metadata: SamplingMetadata,

161 spec_step_idx: int = 0,

162 ) -> Optional[torch.Tensor]:

167 - return self.model.compute_logits(hidden_states, sampling_metadata,

168 - spec_step_idx)

163 + return self.model.compute_logits(hidden_states, spec_step_idx)

164

165 def load_weights(self, weights: Iterable[tuple[str,

166 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/deepseek_v2.py

+1 -4

@@ -56,7 +56,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

56 ParallelLMHead, VocabParallelEmbedding)

57 from vllm.model_executor.model_loader.weight_utils import (

58 default_weight_loader, maybe_remap_kv_scale_name)

59 -from vllm.model_executor.sampling_metadata import SamplingMetadata

59 from vllm.platforms import current_platform

60 from vllm.sequence import IntermediateTensors

61 from vllm.utils import cdiv, direct_register_custom_op

@@ -914,10 +913,8 @@ class DeepseekV2ForCausalLM(nn.Module, SupportsPP, MixtureOfExperts,

913 def compute_logits(

914 self,

915 hidden_states: torch.Tensor,

917 - sampling_metadata: SamplingMetadata,

916 ) -> Optional[torch.Tensor]:

919 - logits = self.logits_processor(self.lm_head, hidden_states,

920 - sampling_metadata)

917 + logits = self.logits_processor(self.lm_head, hidden_states)

918 return logits

919

920 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/deepseek_vl2.py

+1 -4

@@ -15,7 +15,6 @@ from transformers import BatchFeature

15

16 from vllm.config import VllmConfig

17 from vllm.distributed import get_tensor_model_parallel_world_size

18 -from vllm.model_executor import SamplingMetadata

18 from vllm.model_executor.layers.quantization import QuantizationConfig

19 from vllm.model_executor.model_loader.utils import set_default_torch_dtype

20 from vllm.model_executor.models.transformers import replace_linear_class

@@ -647,10 +646,8 @@ class DeepseekVLV2ForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

646 def compute_logits(

647 self,

648 hidden_states: torch.Tensor,

650 - sampling_metadata: SamplingMetadata,

649 ) -> Optional[torch.Tensor]:

652 - return self.language_model.compute_logits(hidden_states,

653 - sampling_metadata)

650 + return self.language_model.compute_logits(hidden_states)

651

652 def load_weights(self, weights: Iterable[tuple[str,

653 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/dots1.py

+1 -4

@@ -52,7 +52,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

52 ParallelLMHead, VocabParallelEmbedding)

53 from vllm.model_executor.model_loader.weight_utils import (

54 default_weight_loader, maybe_remap_kv_scale_name)

55 -from vllm.model_executor.sampling_metadata import SamplingMetadata

55 from vllm.sequence import IntermediateTensors

56

57 from .interfaces import SupportsLoRA, SupportsPP

@@ -534,10 +533,8 @@ class Dots1ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

533 def compute_logits(

534 self,

535 hidden_states: torch.Tensor,

537 - sampling_metadata: SamplingMetadata,

536 ) -> Optional[torch.Tensor]:

539 - logits = self.logits_processor(self.lm_head, hidden_states,

540 - sampling_metadata)

537 + logits = self.logits_processor(self.lm_head, hidden_states)

538 return logits

539

540 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/ernie45_moe.py

+1 -4

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

49 ParallelLMHead, VocabParallelEmbedding)

50 from vllm.model_executor.model_loader.weight_utils import (

51 default_weight_loader, maybe_remap_kv_scale_name)

52 -from vllm.model_executor.sampling_metadata import SamplingMetadata

52 from vllm.sequence import IntermediateTensors

53

54 from .interfaces import SupportsLoRA, SupportsPP

@@ -591,10 +590,8 @@ class Ernie4_5_MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

590 def compute_logits(

591 self,

592 hidden_states: torch.Tensor,

594 - sampling_metadata: SamplingMetadata,

593 ) -> Optional[torch.Tensor]:

596 - logits = self.logits_processor(self.lm_head, hidden_states,

597 - sampling_metadata)

594 + logits = self.logits_processor(self.lm_head, hidden_states)

595 return logits

596

597 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/ernie45_vl.py

+1 -4

@@ -39,7 +39,6 @@ from vllm.config import VllmConfig

39 from vllm.distributed import parallel_state

40 from vllm.distributed import utils as dist_utils

41 from vllm.logger import init_logger

42 -from vllm.model_executor import SamplingMetadata

42 from vllm.model_executor.layers.activation import QuickGELU

43 from vllm.model_executor.layers.layernorm import RMSNorm

44 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

@@ -1292,11 +1291,9 @@ class Ernie4_5_VLMoeForConditionalGeneration(nn.Module, SupportsMultiModal,

1291 def compute_logits(

1292 self,

1293 hidden_states: torch.Tensor,

1295 - sampling_metadata: SamplingMetadata,

1294 ) -> Optional[torch.Tensor]:

1295 """compute logits"""

1298 - return self.language_model.compute_logits(hidden_states,

1299 - sampling_metadata)

1296 + return self.language_model.compute_logits(hidden_states)

1297

1298 def _vision_forward(

1299 self,

vllm/model_executor/models/ernie45_vl_moe.py

+1 -4

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

48 ParallelLMHead, VocabParallelEmbedding)

49 from vllm.model_executor.model_loader.weight_utils import (

50 default_weight_loader, maybe_remap_kv_scale_name)

51 -from vllm.model_executor.sampling_metadata import SamplingMetadata

51 from vllm.sequence import IntermediateTensors

52

53 from .ernie45_moe import Ernie4_5_MoeMLP

@@ -587,10 +586,8 @@ class Ernie4_5_VLMoeForCausalLM(nn.Module, SupportsPP):

586 def compute_logits(

587 self,

588 hidden_states: torch.Tensor,

590 - sampling_metadata: SamplingMetadata,

589 ) -> Optional[torch.Tensor]:

592 - logits = self.logits_processor(self.lm_head, hidden_states,

593 - sampling_metadata)

590 + logits = self.logits_processor(self.lm_head, hidden_states)

591 return logits

592

593 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/ernie_mtp.py

+2 -6

@@ -36,7 +36,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

36 from vllm.model_executor.layers.vocab_parallel_embedding import (

37 ParallelLMHead, VocabParallelEmbedding)

38 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

39 -from vllm.model_executor.sampling_metadata import SamplingMetadata

39 from vllm.sequence import IntermediateTensors

40

41 from .interfaces import SupportsPP

@@ -138,12 +137,10 @@ class ErnieMultiTokenPredictor(nn.Module):

137 self,

138 hidden_states: torch.Tensor,

139 lm_head: ParallelLMHead,

141 - sampling_metadata: SamplingMetadata,

140 spec_step_idx: int = 0,

141 ) -> torch.Tensor:

142 self.layers[str(self.mtp_start_layer_idx + spec_step_idx)]

145 - logits = self.logits_processor(lm_head, hidden_states,

146 - sampling_metadata)

143 + logits = self.logits_processor(lm_head, hidden_states)

144 return logits

145

146

@@ -180,11 +177,10 @@ class ErnieMTP(nn.Module, SupportsPP):

177 def compute_logits(

178 self,

179 hidden_states: torch.Tensor,

183 - sampling_metadata: SamplingMetadata,

180 spec_step_idx: int = 0,

181 ) -> Optional[torch.Tensor]:

182 return self.model.compute_logits(hidden_states, self.lm_head,

187 - sampling_metadata, spec_step_idx)

183 + spec_step_idx)

184

185 def load_weights(self, weights: Iterable[tuple[str,

186 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/exaone.py

+1 -4

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

49 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

50 from vllm.model_executor.model_loader.weight_utils import (

51 default_weight_loader, maybe_remap_kv_scale_name)

52 -from vllm.model_executor.sampling_metadata import SamplingMetadata

52 from vllm.sequence import IntermediateTensors

53

54 from .interfaces import SupportsLoRA, SupportsPP

@@ -534,10 +533,8 @@ class ExaoneForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

533 def compute_logits(

534 self,

535 hidden_states: torch.Tensor,

537 - sampling_metadata: SamplingMetadata,

536 ) -> Optional[torch.Tensor]:

539 - logits = self.logits_processor(self.lm_head, hidden_states,

540 - sampling_metadata)

537 + logits = self.logits_processor(self.lm_head, hidden_states)

538 return logits

539

540 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/exaone4.py

+1 -4

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

45 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

46 from vllm.model_executor.model_loader.weight_utils import (

47 default_weight_loader, maybe_remap_kv_scale_name)

48 -from vllm.model_executor.sampling_metadata import SamplingMetadata

48 from vllm.sequence import IntermediateTensors

49

50 from .interfaces import SupportsLoRA, SupportsPP

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

516 def compute_logits(

517 self,

518 hidden_states: torch.Tensor,

520 - sampling_metadata: SamplingMetadata,

519 ) -> Optional[torch.Tensor]:

522 - logits = self.logits_processor(self.lm_head, hidden_states,

523 - sampling_metadata)

520 + logits = self.logits_processor(self.lm_head, hidden_states)

521 return logits

522

523 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/falcon.py

+1 -4

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

46 from vllm.model_executor.layers.vocab_parallel_embedding import (

47 ParallelLMHead, VocabParallelEmbedding)

48 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

49 -from vllm.model_executor.sampling_metadata import SamplingMetadata

49 from vllm.sequence import IntermediateTensors

50 from vllm.transformers_utils.configs import RWConfig

51

@@ -496,10 +495,8 @@ class FalconForCausalLM(nn.Module, SupportsPP):

495 def compute_logits(

496 self,

497 hidden_states: torch.Tensor,

499 - sampling_metadata: SamplingMetadata,

498 ) -> Optional[torch.Tensor]:

501 - logits = self.logits_processor(self.lm_head, hidden_states,

502 - sampling_metadata)

499 + logits = self.logits_processor(self.lm_head, hidden_states)

500 return logits

501

502 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/falcon_h1.py

+1 -4

@@ -33,7 +33,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

33 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

34 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

35 MambaCacheParams)

36 -from vllm.model_executor.sampling_metadata import SamplingMetadata

36 from vllm.sequence import IntermediateTensors

37

38 from .interfaces import HasInnerState, IsHybrid, SupportsLoRA, SupportsPP

@@ -675,10 +674,8 @@ class FalconH1ForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

674 def compute_logits(

675 self,

676 hidden_states: torch.Tensor,

678 - sampling_metadata: SamplingMetadata,

677 ) -> Optional[torch.Tensor]:

680 - logits = self.logits_processor(self.lm_head, hidden_states,

681 - sampling_metadata)

678 + logits = self.logits_processor(self.lm_head, hidden_states)

679

680 return logits

681

vllm/model_executor/models/fuyu.py

+1 -3

@@ -29,7 +29,6 @@ from transformers import (BatchFeature, FuyuConfig, FuyuImageProcessor,

29 from vllm.config import VllmConfig

30 from vllm.model_executor.layers.linear import ColumnParallelLinear

31 from vllm.model_executor.models.persimmon import PersimmonForCausalLM

32 -from vllm.model_executor.sampling_metadata import SamplingMetadata

32 from vllm.multimodal import MULTIMODAL_REGISTRY

33 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

34 MultiModalKwargsItems)

@@ -389,10 +388,9 @@ class FuyuForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

388 def compute_logits(

389 self,

390 hidden_states: torch.Tensor,

392 - sampling_metadata: SamplingMetadata,

391 ) -> Optional[torch.Tensor]:

392 logits = self.language_model.logits_processor(

395 - self.language_model.lm_head, hidden_states, sampling_metadata)

393 + self.language_model.lm_head, hidden_states)

394 return logits

395

396 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gemma.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsLoRA, SupportsPP

@@ -412,10 +411,8 @@ class GemmaForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

411 def compute_logits(

412 self,

413 hidden_states: torch.Tensor,

415 - sampling_metadata: SamplingMetadata,

414 ) -> Optional[torch.Tensor]:

417 - logits = self.logits_processor(self.model.embed_tokens, hidden_states,

418 - sampling_metadata)

415 + logits = self.logits_processor(self.model.embed_tokens, hidden_states)

416 return logits

417

418 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gemma2.py

+1 -4

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

41 VocabParallelEmbedding)

42 from vllm.model_executor.model_loader.weight_utils import (

43 default_weight_loader, maybe_remap_kv_scale_name)

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsLoRA, SupportsPP

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

408 def compute_logits(

409 self,

410 hidden_states: torch.Tensor,

412 - sampling_metadata: SamplingMetadata,

411 ) -> Optional[torch.Tensor]:

414 - logits = self.logits_processor(self.model.embed_tokens, hidden_states,

415 - sampling_metadata)

412 + logits = self.logits_processor(self.model.embed_tokens, hidden_states)

413 return logits

414

415 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gemma3.py

+1 -4

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

41 VocabParallelEmbedding)

42 from vllm.model_executor.model_loader.weight_utils import (

43 default_weight_loader, maybe_remap_kv_scale_name)

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from ...attention.layers.encoder_only_attention import EncoderOnlyAttention

@@ -542,10 +541,8 @@ class Gemma3ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

541 def compute_logits(

542 self,

543 hidden_states: torch.Tensor,

545 - sampling_metadata: SamplingMetadata,

544 ) -> Optional[torch.Tensor]:

547 - logits = self.logits_processor(self.model.embed_tokens, hidden_states,

548 - sampling_metadata)

545 + logits = self.logits_processor(self.model.embed_tokens, hidden_states)

546 return logits

547

548 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gemma3_mm.py

+1 -4

@@ -14,7 +14,6 @@ from vllm.config import VllmConfig

14 from vllm.logger import init_logger

15 from vllm.model_executor.layers.layernorm import GemmaRMSNorm

16 from vllm.model_executor.models.module_mapping import MultiModelKeys

17 -from vllm.model_executor.sampling_metadata import SamplingMetadata

17 from vllm.multimodal import MULTIMODAL_REGISTRY

18 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

19 MultiModalKwargsItems)

@@ -704,10 +703,8 @@ class Gemma3ForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP,

703 def compute_logits(

704 self,

705 hidden_states: torch.Tensor,

707 - sampling_metadata: SamplingMetadata,

706 ) -> Optional[torch.Tensor]:

709 - return self.language_model.compute_logits(hidden_states,

710 - sampling_metadata)

707 + return self.language_model.compute_logits(hidden_states)

708

709 def load_weights(self, weights: Iterable[tuple[str,

710 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/gemma3n.py

+1 -4

@@ -43,7 +43,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

43 VocabParallelEmbedding)

44 from vllm.model_executor.model_loader.weight_utils import (

45 default_weight_loader, maybe_remap_kv_scale_name)

46 -from vllm.model_executor.sampling_metadata import SamplingMetadata

46 from vllm.sequence import IntermediateTensors

47

48 from .interfaces import SupportsQuant

@@ -814,10 +813,8 @@ class Gemma3nForCausalLM(nn.Module):

813 def compute_logits(

814 self,

815 hidden_states: torch.Tensor,

817 - sampling_metadata: Optional[SamplingMetadata],

816 ) -> Optional[torch.Tensor]:

819 - logits = self.logits_processor(self.model.embed_tokens, hidden_states,

820 - sampling_metadata)

817 + logits = self.logits_processor(self.model.embed_tokens, hidden_states)

818 return logits

819

820 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gemma3n_mm.py

+1 -4

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

25 from vllm.model_executor.models.gemma3n import Gemma3nForCausalLM

26 from vllm.model_executor.models.module_mapping import MultiModelKeys

27 from vllm.model_executor.models.whisper import ISO639_1_SUPPORTED_LANGS

28 -from vllm.model_executor.sampling_metadata import SamplingMetadata

28 from vllm.multimodal import MULTIMODAL_REGISTRY

29 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

30 MultiModalKwargsItems)

@@ -685,10 +684,8 @@ class Gemma3nForConditionalGeneration(nn.Module, SupportsMultiModal,

684 def compute_logits(

685 self,

686 hidden_states: torch.Tensor,

688 - sampling_metadata: SamplingMetadata,

687 ) -> Optional[torch.Tensor]:

690 - return self.language_model.compute_logits(hidden_states,

691 - sampling_metadata)

688 + return self.language_model.compute_logits(hidden_states)

689

690 def load_weights(self, weights: Iterable[tuple[str,

691 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/glm4.py

+1 -4

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

40 from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.rotary_embedding import get_rope

42 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

43 -from vllm.model_executor.sampling_metadata import SamplingMetadata

43 from vllm.sequence import IntermediateTensors

44

45 from .interfaces import SupportsLoRA, SupportsPP

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

288 def compute_logits(

289 self,

290 hidden_states: torch.Tensor,

292 - sampling_metadata: SamplingMetadata,

291 ) -> Optional[torch.Tensor]:

294 - logits = self.logits_processor(self.lm_head, hidden_states,

295 - sampling_metadata)

292 + logits = self.logits_processor(self.lm_head, hidden_states)

293 return logits

294

295 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/glm4_1v.py

+1 -4

@@ -52,7 +52,6 @@ from vllm.distributed import (get_tensor_model_parallel_world_size,

52 parallel_state)

53 from vllm.distributed import utils as dist_utils

54 from vllm.logger import init_logger

55 -from vllm.model_executor import SamplingMetadata

55 from vllm.model_executor.layers.layernorm import RMSNorm

56 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

57 MergedColumnParallelLinear,

@@ -1654,10 +1653,8 @@ class Glm4vForConditionalGeneration(nn.Module, SupportsMultiModal,

1653 def compute_logits(

1654 self,

1655 hidden_states: torch.Tensor,

1657 - sampling_metadata: SamplingMetadata,

1656 ) -> Optional[torch.Tensor]:

1659 - return self.language_model.compute_logits(hidden_states,

1660 - sampling_metadata)

1657 + return self.language_model.compute_logits(hidden_states)

1658

1659 def load_weights(self, weights: Iterable[tuple[str,

1660 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/glm4_moe.py

+1 -4

@@ -51,7 +51,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

51 ParallelLMHead, VocabParallelEmbedding)

52 from vllm.model_executor.model_loader.weight_utils import (

53 default_weight_loader, maybe_remap_kv_scale_name)

54 -from vllm.model_executor.sampling_metadata import SamplingMetadata

54 from vllm.sequence import IntermediateTensors

55

56 from .interfaces import SupportsLoRA, SupportsPP

@@ -703,10 +702,8 @@ class Glm4MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

702 def compute_logits(

703 self,

704 hidden_states: torch.Tensor,

706 - sampling_metadata: SamplingMetadata,

705 ) -> Optional[torch.Tensor]:

708 - logits = self.logits_processor(self.lm_head, hidden_states,

709 - sampling_metadata)

706 + logits = self.logits_processor(self.lm_head, hidden_states)

707 return logits

708

709 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/glm4_moe_mtp.py

+2 -7

@@ -38,7 +38,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

38 from vllm.model_executor.layers.vocab_parallel_embedding import (

39 ParallelLMHead, VocabParallelEmbedding)

40 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

41 -from vllm.model_executor.sampling_metadata import SamplingMetadata

41 from vllm.sequence import IntermediateTensors

42

43 from .glm4_moe import Glm4MoeDecoderLayer, get_spec_layer_idx_from_weight_name

@@ -155,15 +154,13 @@ class Glm4MoeMultiTokenPredictor(nn.Module):

154 def compute_logits(

155 self,

156 hidden_states: torch.Tensor,

158 - sampling_metadata: SamplingMetadata,

157 spec_step_idx: int = 0,

158 ) -> torch.Tensor:

159 current_step_idx = (spec_step_idx % self.num_mtp_layers)

160 mtp_layer = self.layers[str(self.mtp_start_layer_idx +

161 current_step_idx)]

162 logits = self.logits_processor(mtp_layer.shared_head.head,

165 - mtp_layer.shared_head(hidden_states),

166 - sampling_metadata)

163 + mtp_layer.shared_head(hidden_states))

164 return logits

165

166

@@ -192,11 +189,9 @@ class Glm4MoeMTP(nn.Module, SupportsPP):

189 def compute_logits(

190 self,

191 hidden_states: torch.Tensor,

195 - sampling_metadata: SamplingMetadata,

192 spec_step_idx: int = 0,

193 ) -> Optional[torch.Tensor]:

198 - return self.model.compute_logits(hidden_states, sampling_metadata,

199 - spec_step_idx)

194 + return self.model.compute_logits(hidden_states, spec_step_idx)

195

196 def load_weights(self, weights: Iterable[tuple[str,

197 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/gpt2.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 ParallelLMHead, VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from ..layers.pooler import DispatchPooler, Pooler

@@ -307,10 +306,8 @@ class GPT2LMHeadModel(nn.Module, SupportsPP):

306 def compute_logits(

307 self,

308 hidden_states: torch.Tensor,

310 - sampling_metadata: SamplingMetadata,

309 ) -> Optional[torch.Tensor]:

312 - logits = self.logits_processor(self.lm_head, hidden_states,

313 - sampling_metadata)

310 + logits = self.logits_processor(self.lm_head, hidden_states)

311 return logits

312

313 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gpt_bigcode.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 ParallelLMHead, VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsLoRA, SupportsPP

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

328 def compute_logits(

329 self,

330 hidden_states: torch.Tensor,

332 - sampling_metadata: SamplingMetadata,

331 ) -> Optional[torch.Tensor]:

334 - logits = self.logits_processor(self.lm_head, hidden_states,

335 - sampling_metadata)

332 + logits = self.logits_processor(self.lm_head, hidden_states)

333 return logits

334

335 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gpt_j.py

+1 -3

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

41 ParallelLMHead, VocabParallelEmbedding)

42 from vllm.model_executor.model_loader.weight_utils import (

43 default_weight_loader, maybe_remap_kv_scale_name)

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsPP

@@ -329,10 +328,9 @@ class GPTJForCausalLM(nn.Module, SupportsPP):

328 def compute_logits(

329 self,

330 hidden_states: torch.Tensor,

332 - sampling_metadata: SamplingMetadata,

331 ) -> Optional[torch.Tensor]:

332 logits = self.logits_processor(self.lm_head, hidden_states,

335 - sampling_metadata, self.lm_head.bias)

333 + self.lm_head.bias)

334 return logits

335

336 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gpt_neox.py

+1 -4

@@ -40,7 +40,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

40 from vllm.model_executor.layers.vocab_parallel_embedding import (

41 ParallelLMHead, VocabParallelEmbedding)

42 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

43 -from vllm.model_executor.sampling_metadata import SamplingMetadata

43 from vllm.sequence import IntermediateTensors

44

45 from .interfaces import SupportsPP

@@ -321,10 +320,8 @@ class GPTNeoXForCausalLM(nn.Module, SupportsPP):

320 def compute_logits(

321 self,

322 hidden_states: torch.Tensor,

324 - sampling_metadata: SamplingMetadata,

323 ) -> Optional[torch.Tensor]:

326 - logits = self.logits_processor(self.embed_out, hidden_states,

327 - sampling_metadata)

324 + logits = self.logits_processor(self.embed_out, hidden_states)

325 return logits

326

327 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/gpt_oss.py

+2 -5

@@ -24,7 +24,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

24 from vllm.model_executor.layers.vocab_parallel_embedding import (

25 ParallelLMHead, VocabParallelEmbedding)

26 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

27 -from vllm.model_executor.sampling_metadata import SamplingMetadata

27 from vllm.sequence import IntermediateTensors

28 from vllm.utils import cdiv

29

@@ -670,10 +669,8 @@ class GptOssForCausalLM(nn.Module, SupportsPP):

669 return self.model(input_ids, positions, intermediate_tensors,

670 inputs_embeds)

671

673 - def compute_logits(self, hidden_states: torch.Tensor,

674 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

675 - logits = self.logits_processor(self.lm_head, hidden_states,

676 - sampling_metadata)

672 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

673 + logits = self.logits_processor(self.lm_head, hidden_states)

674 return logits

675

676 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/granite.py

+3 -6

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

48 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

49 from vllm.model_executor.model_loader.weight_utils import (

50 default_weight_loader, maybe_remap_kv_scale_name)

51 -from vllm.model_executor.sampling_metadata import SamplingMetadata

51 from vllm.sequence import IntermediateTensors

52

53 from .interfaces import SupportsLoRA, SupportsPP

@@ -463,11 +462,9 @@ class GraniteForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

462 inputs_embeds)

463 return model_output

464

466 - def compute_logits(

467 - self, hidden_states: torch.Tensor,

468 - sampling_metadata: SamplingMetadata) -> Optional[torch.Tensor]:

469 - logits = self.logits_processor(self.lm_head, hidden_states,

470 - sampling_metadata)

465 + def compute_logits(self,

466 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

467 + logits = self.logits_processor(self.lm_head, hidden_states)

468 return logits

469

470 def make_empty_intermediate_tensors(

vllm/model_executor/models/granite_speech.py

+1 -6

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

37 RowParallelLinear)

38 from vllm.model_executor.layers.quantization import QuantizationConfig

39 from vllm.model_executor.models.module_mapping import MultiModelKeys

40 -from vllm.model_executor.sampling_metadata import SamplingMetadata

40 from vllm.multimodal import MULTIMODAL_REGISTRY

41 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

42 MultiModalKwargsItems)

@@ -776,12 +775,8 @@ class GraniteSpeechForConditionalGeneration(

775 def compute_logits(

776 self,

777 hidden_states: torch.Tensor,

779 - sampling_metadata: SamplingMetadata,

778 ) -> Optional[torch.Tensor]:

781 - return self.language_model.compute_logits(

782 - hidden_states,

783 - sampling_metadata,

784 - )

779 + return self.language_model.compute_logits(hidden_states)

780

781 def load_weights(

782 self,

vllm/model_executor/models/granitemoe.py

+3 -6

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

48 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

49 from vllm.model_executor.model_loader.weight_utils import (

50 default_weight_loader, maybe_remap_kv_scale_name)

51 -from vllm.model_executor.sampling_metadata import SamplingMetadata

51 from vllm.sequence import IntermediateTensors

52

53 from .interfaces import SupportsLoRA, SupportsPP

@@ -511,11 +510,9 @@ class GraniteMoeForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

510 inputs_embeds)

511 return hidden_states

512

514 - def compute_logits(

515 - self, hidden_states: torch.Tensor,

516 - sampling_metadata: SamplingMetadata) -> Optional[torch.Tensor]:

517 - logits = self.logits_processor(self.lm_head, hidden_states,

518 - sampling_metadata)

513 + def compute_logits(self,

514 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

515 + logits = self.logits_processor(self.lm_head, hidden_states)

516 return logits

517

518 def make_empty_intermediate_tensors(

vllm/model_executor/models/granitemoehybrid.py

+1 -4

@@ -32,7 +32,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

32 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

33 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

34 MambaCacheParams)

35 -from vllm.model_executor.sampling_metadata import SamplingMetadata

35 from vllm.sequence import IntermediateTensors

36 from vllm.utils import LayerBlockType

37

@@ -672,10 +671,8 @@ class GraniteMoeHybridForCausalLM(nn.Module, HasInnerState, SupportsLoRA,

671 def compute_logits(

672 self,

673 hidden_states: torch.Tensor,

675 - sampling_metadata: SamplingMetadata,

674 ) -> Optional[torch.Tensor]:

677 - logits = self.logits_processor(self.lm_head, hidden_states,

678 - sampling_metadata)

675 + logits = self.logits_processor(self.lm_head, hidden_states)

676 return logits

677

678 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/granitemoeshared.py

+3 -6

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

25 QuantizationConfig)

26 from vllm.model_executor.layers.vocab_parallel_embedding import (

27 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

28 -from vllm.model_executor.sampling_metadata import SamplingMetadata

28 from vllm.sequence import IntermediateTensors

29

30 from .granitemoe import GraniteMoeAttention, GraniteMoeModel, GraniteMoeMoE

@@ -311,11 +310,9 @@ class GraniteMoeSharedForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

310 inputs_embeds)

311 return hidden_states

312

314 - def compute_logits(

315 - self, hidden_states: torch.Tensor,

316 - sampling_metadata: SamplingMetadata) -> Optional[torch.Tensor]:

317 - logits = self.logits_processor(self.lm_head, hidden_states,

318 - sampling_metadata)

313 + def compute_logits(self,

314 + hidden_states: torch.Tensor) -> Optional[torch.Tensor]:

315 + logits = self.logits_processor(self.lm_head, hidden_states)

316 return logits

317

318 def make_empty_intermediate_tensors(

vllm/model_executor/models/grok1.py

+1 -4

@@ -46,7 +46,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

46 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

47 from vllm.model_executor.model_loader.weight_utils import (

48 default_weight_loader, maybe_remap_kv_scale_name)

49 -from vllm.model_executor.sampling_metadata import SamplingMetadata

49 from vllm.sequence import IntermediateTensors

50

51 from .interfaces import SupportsLoRA, SupportsPP

@@ -528,10 +527,8 @@ class Grok1ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

527 def compute_logits(

528 self,

529 hidden_states: torch.Tensor,

531 - sampling_metadata: SamplingMetadata,

530 ) -> Optional[torch.Tensor]:

533 - logits = self.logits_processor(self.lm_head, hidden_states,

534 - sampling_metadata)

531 + logits = self.logits_processor(self.lm_head, hidden_states)

532 return logits

533

534 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/hunyuan_v1.py

+1 -4

@@ -54,7 +54,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

54 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

55 from vllm.model_executor.model_loader.weight_utils import (

56 default_weight_loader, maybe_remap_kv_scale_name)

57 -from vllm.model_executor.sampling_metadata import SamplingMetadata

57 from vllm.sequence import IntermediateTensors

58

59 from .interfaces import MixtureOfExperts, SupportsLoRA, SupportsPP

@@ -1004,10 +1003,8 @@ class HunYuanV1Base(nn.Module, SupportsLoRA, SupportsPP, MixtureOfExperts):

1003 def compute_logits(

1004 self,

1005 hidden_states: torch.Tensor,

1007 - sampling_metadata: SamplingMetadata,

1006 ) -> Optional[torch.Tensor]:

1009 - logits = self.logits_processor(self.lm_head, hidden_states,

1010 - sampling_metadata)

1007 + logits = self.logits_processor(self.lm_head, hidden_states)

1008 return logits

1009

1010 def make_empty_intermediate_tensors(

vllm/model_executor/models/hyperclovax_vision.py

+1 -4

@@ -31,7 +31,6 @@ from transformers.modeling_utils import no_init_weights

31 from vllm.config import VllmConfig

32 from vllm.inputs import InputProcessingContext

33 from vllm.model_executor.layers.quantization import QuantizationConfig

34 -from vllm.model_executor.sampling_metadata import SamplingMetadata

34 from vllm.multimodal import MULTIMODAL_REGISTRY

35 from vllm.multimodal.cache import BaseMultiModalProcessorCache

36 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -962,10 +961,8 @@ class HCXVisionForCausalLM(nn.Module, SupportsMultiModal, SupportsPP):

961 def compute_logits(

962 self,

963 hidden_states: torch.Tensor,

965 - sampling_metadata: SamplingMetadata,

964 ) -> Optional[torch.Tensor]:

967 - return self.language_model.compute_logits(hidden_states,

968 - sampling_metadata)

965 + return self.language_model.compute_logits(hidden_states)

966

967 def load_weights(

968 self,

vllm/model_executor/models/idefics3.py

+2 -5

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

31 from vllm.model_executor.layers.quantization import QuantizationConfig

32 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

33 from vllm.model_executor.models.module_mapping import MultiModelKeys

34 -from vllm.model_executor.sampling_metadata import SamplingMetadata

34 from vllm.multimodal import MULTIMODAL_REGISTRY

35 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

36 MultiModalKwargsItems)

@@ -738,10 +737,8 @@ class Idefics3ForConditionalGeneration(nn.Module, SupportsMultiModal,

737

738 return hidden_states

739

741 - def compute_logits(self, hidden_states: torch.Tensor,

742 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

743 - logits = self.logits_processor(self.lm_head, hidden_states,

744 - sampling_metadata)

740 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

741 + logits = self.logits_processor(self.lm_head, hidden_states)

742 return logits

743

744 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/interfaces_base.py

-3

@@ -13,11 +13,9 @@ from vllm.utils import supports_kw

13 if TYPE_CHECKING:

14 from vllm.config import VllmConfig

15 from vllm.model_executor.layers.pooler import Pooler

16 - from vllm.model_executor.sampling_metadata import SamplingMetadata

16 else:

17 VllmConfig = Any

18 Pooler = Any

20 - SamplingMetadata = Any

19

20 logger = init_logger(__name__)

21

@@ -100,7 +98,6 @@ class VllmModelForTextGeneration(VllmModel[T], Protocol[T]):

98 def compute_logits(

99 self,

100 hidden_states: T,

103 - sampling_metadata: SamplingMetadata,

101 ) -> Optional[T]:

102 """Return `None` if TP rank > 0."""

103 ...

vllm/model_executor/models/internlm2.py

+1 -4

@@ -29,7 +29,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

29 from vllm.model_executor.layers.vocab_parallel_embedding import (

30 ParallelLMHead, VocabParallelEmbedding)

31 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

32 -from vllm.model_executor.sampling_metadata import SamplingMetadata

32 from vllm.sequence import IntermediateTensors

33

34 from .interfaces import SupportsLoRA, SupportsPP

@@ -358,10 +357,8 @@ class InternLM2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

357 def compute_logits(

358 self,

359 hidden_states: torch.Tensor,

361 - sampling_metadata: SamplingMetadata,

360 ) -> Optional[torch.Tensor]:

363 - logits = self.logits_processor(self.output, hidden_states,

364 - sampling_metadata)

361 + logits = self.logits_processor(self.output, hidden_states)

362 return logits

363

364 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/interns1.py

+1 -4

@@ -21,7 +21,6 @@ from vllm.config import VllmConfig

21 from vllm.model_executor.layers.quantization import QuantizationConfig

22 from vllm.model_executor.models.interns1_vit import InternS1VisionModel

23 from vllm.model_executor.models.module_mapping import MultiModelKeys

24 -from vllm.model_executor.sampling_metadata import SamplingMetadata

24 from vllm.multimodal import MULTIMODAL_REGISTRY

25 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

26 MultiModalKwargsItems, NestedTensors)

@@ -812,10 +811,8 @@ class InternS1ForConditionalGeneration(nn.Module, SupportsMultiModal,

811 def compute_logits(

812 self,

813 hidden_states: torch.Tensor,

815 - sampling_metadata: SamplingMetadata,

814 ) -> Optional[torch.Tensor]:

817 - return self.language_model.compute_logits(hidden_states,

818 - sampling_metadata)

815 + return self.language_model.compute_logits(hidden_states)

816

817 def load_weights(self, weights: Iterable[tuple[str,

818 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/internvl.py

+1 -4

@@ -25,7 +25,6 @@ from vllm.model_executor.layers.quantization.awq import AWQConfig

25 from vllm.model_executor.models.intern_vit import (InternVisionModel,

26 InternVisionPatchModel)

27 from vllm.model_executor.models.module_mapping import MultiModelKeys

28 -from vllm.model_executor.sampling_metadata import SamplingMetadata

28 from vllm.multimodal import MULTIMODAL_REGISTRY

29 from vllm.multimodal.image import convert_image_mode

30 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -1399,10 +1398,8 @@ class InternVLChatModel(nn.Module, SupportsMultiModal, SupportsPP,

1398 def compute_logits(

1399 self,

1400 hidden_states: torch.Tensor,

1402 - sampling_metadata: SamplingMetadata,

1401 ) -> Optional[torch.Tensor]:

1404 - return self.language_model.compute_logits(hidden_states,

1405 - sampling_metadata)

1402 + return self.language_model.compute_logits(hidden_states)

1403

1404 def load_weights(self, weights: Iterable[tuple[str,

1405 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/jais.py

+1 -4

@@ -42,7 +42,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

42 from vllm.model_executor.layers.vocab_parallel_embedding import (

43 ParallelLMHead, VocabParallelEmbedding)

44 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

45 -from vllm.model_executor.sampling_metadata import SamplingMetadata

45 from vllm.sequence import IntermediateTensors

46 from vllm.transformers_utils.configs import JAISConfig

47

@@ -332,10 +331,8 @@ class JAISLMHeadModel(nn.Module, SupportsPP):

331 def compute_logits(

332 self,

333 hidden_states: torch.Tensor,

335 - sampling_metadata: SamplingMetadata,

334 ) -> Optional[torch.Tensor]:

337 - logits = self.logits_processor(self.lm_head, hidden_states,

338 - sampling_metadata)

335 + logits = self.logits_processor(self.lm_head, hidden_states)

336 return logits

337

338 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/jamba.py

+1 -4

@@ -32,7 +32,6 @@ from vllm.model_executor.model_loader.weight_utils import default_weight_loader

32 from vllm.model_executor.models.llama import LlamaMLP as JambaMLP

33 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

34 MambaCacheParams)

35 -from vllm.model_executor.sampling_metadata import SamplingMetadata

35 from vllm.sequence import IntermediateTensors

36 from vllm.utils import LayerBlockType

37

@@ -581,10 +580,8 @@ class JambaForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

580 def compute_logits(

581 self,

582 hidden_states: torch.Tensor,

584 - sampling_metadata: SamplingMetadata,

583 ) -> Optional[torch.Tensor]:

586 - logits = self.logits_processor(self.lm_head, hidden_states,

587 - sampling_metadata)

584 + logits = self.logits_processor(self.lm_head, hidden_states)

585 return logits

586

587 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/keye.py

+1 -4

@@ -21,7 +21,6 @@ from vllm.attention.layer import check_upstream_fa_availability

21 from vllm.config import VllmConfig

22 from vllm.distributed import get_tensor_model_parallel_world_size

23 from vllm.logger import init_logger

24 -from vllm.model_executor import SamplingMetadata

24 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

25 QKVParallelLinear,

26 RowParallelLinear)

@@ -1556,10 +1555,8 @@ class BaseKeyeModule(nn.Module):

1555 def compute_logits(

1556 self,

1557 hidden_states: torch.Tensor,

1559 - sampling_metadata: SamplingMetadata,

1558 ) -> Optional[torch.Tensor]:

1561 - return self.language_model.compute_logits(hidden_states,

1562 - sampling_metadata)

1559 + return self.language_model.compute_logits(hidden_states)

1560

1561 def load_weights(self, weights: Iterable[tuple[str,

1562 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/kimi_vl.py

+1 -4

@@ -67,7 +67,6 @@ from vllm.model_executor.models.interfaces import (SupportsMultiModal,

67 SupportsPP)

68 from vllm.model_executor.models.moonvit import MoonVitPretrainedModel

69 from vllm.model_executor.models.utils import merge_multimodal_embeddings

70 -from vllm.model_executor.sampling_metadata import SamplingMetadata

70 from vllm.multimodal import MULTIMODAL_REGISTRY

71 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

72 MultiModalKwargsItems, NestedTensors)

@@ -484,10 +483,8 @@ class KimiVLForConditionalGeneration(nn.Module, SupportsMultiModal,

483 return hidden_states

484

485 def compute_logits(self, hidden_states: torch.Tensor,

487 - sampling_metadata: SamplingMetadata,

486 **kwargs) -> torch.Tensor:

489 - logits = self.logits_processor(self.lm_head, hidden_states,

490 - sampling_metadata, **kwargs)

487 + logits = self.logits_processor(self.lm_head, hidden_states, **kwargs)

488 return logits

489

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

vllm/model_executor/models/lfm2.py

+2 -5

@@ -27,7 +27,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

27 from vllm.model_executor.layers.vocab_parallel_embedding import (

28 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

29 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

30 -from vllm.model_executor.sampling_metadata import SamplingMetadata

30 from vllm.sequence import IntermediateTensors

31

32 from .interfaces import (HasInnerState, IsHybrid, SupportsLoRA, SupportsPP,

@@ -542,10 +541,8 @@ class Lfm2ForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

541 inputs_embeds)

542 return hidden_states

543

545 - def compute_logits(self, hidden_states: torch.Tensor,

546 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

547 - logits = self.logits_processor(self.lm_head, hidden_states,

548 - sampling_metadata)

544 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

545 + logits = self.logits_processor(self.lm_head, hidden_states)

546 return logits

547

548 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/llama.py

+1 -4

@@ -48,7 +48,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

48 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

49 from vllm.model_executor.model_loader.weight_utils import (

50 default_weight_loader, maybe_remap_kv_scale_name)

51 -from vllm.model_executor.sampling_metadata import SamplingMetadata

51 from vllm.sequence import IntermediateTensors

52

53 from .interfaces import SupportsEagle3, SupportsLoRA, SupportsPP

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

600 def compute_logits(

601 self,

602 hidden_states: torch.Tensor,

604 - sampling_metadata: SamplingMetadata,

603 ) -> Optional[torch.Tensor]:

606 - logits = self.logits_processor(self.lm_head, hidden_states,

607 - sampling_metadata)

604 + logits = self.logits_processor(self.lm_head, hidden_states)

605 return logits

606

607 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/llama_eagle3.py

+1 -4

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

21 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

22 from vllm.model_executor.models.llama import (LlamaDecoderLayer,

23 LlamaForCausalLM)

24 -from vllm.v1.sample.metadata import SamplingMetadata

24

25 from .utils import AutoWeightsLoader, maybe_prefix

26

@@ -244,10 +243,8 @@ class Eagle3LlamaForCausalLM(LlamaForCausalLM):

243 def compute_logits(

244 self,

245 hidden_states: torch.Tensor,

247 - sampling_metadata: SamplingMetadata,

246 ) -> Optional[torch.Tensor]:

249 - logits = self.logits_processor(self.lm_head, hidden_states,

250 - sampling_metadata)

247 + logits = self.logits_processor(self.lm_head, hidden_states)

248 if self.draft_id_to_target_id is None:

249 assert logits.shape[1] == self.config.vocab_size, \

250 "Expected logits to have shape " \

vllm/model_executor/models/llava.py

+1 -4

@@ -20,7 +20,6 @@ from vllm.model_executor.layers.activation import get_act_fn

20 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

21 RowParallelLinear)

22 from vllm.model_executor.layers.quantization import QuantizationConfig

23 -from vllm.model_executor.sampling_metadata import SamplingMetadata

23 from vllm.multimodal import MULTIMODAL_REGISTRY

24 from vllm.multimodal.cache import BaseMultiModalProcessorCache

25 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -760,10 +759,8 @@ class LlavaForConditionalGeneration(nn.Module, SupportsMultiModal, SupportsPP):

759 def compute_logits(

760 self,

761 hidden_states: torch.Tensor,

763 - sampling_metadata: SamplingMetadata,

762 ) -> Optional[torch.Tensor]:

765 - return self.language_model.compute_logits(hidden_states,

766 - sampling_metadata)

763 + return self.language_model.compute_logits(hidden_states)

764

765 def load_weights(self, weights: Iterable[tuple[str,

766 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/llava_next.py

+1 -4

@@ -13,7 +13,6 @@ from transformers.models.llava_next.modeling_llava_next import (

13 get_anyres_image_grid_shape, unpad_image)

14

15 from vllm.config import VllmConfig

16 -from vllm.model_executor.sampling_metadata import SamplingMetadata

16 from vllm.multimodal import MULTIMODAL_REGISTRY

17 from vllm.multimodal.inputs import MultiModalFieldConfig

18 from vllm.multimodal.parse import ImageSize

@@ -563,10 +562,8 @@ model_executor.models.llava_next.LlavaNextProcessingInfo.get_num_image_tokens].

562 def compute_logits(

563 self,

564 hidden_states: torch.Tensor,

566 - sampling_metadata: SamplingMetadata,

565 ) -> Optional[torch.Tensor]:

568 - return self.language_model.compute_logits(hidden_states,

569 - sampling_metadata)

566 + return self.language_model.compute_logits(hidden_states)

567

568 def load_weights(self, weights: Iterable[tuple[str,

569 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/llava_next_video.py

+1 -4

@@ -13,7 +13,6 @@ from transformers import (BatchFeature, LlavaNextVideoConfig,

13 from vllm.config import VllmConfig

14 from vllm.model_executor.layers.activation import get_act_fn

15 from vllm.model_executor.models.clip import CLIPVisionModel

16 -from vllm.model_executor.sampling_metadata import SamplingMetadata

16 from vllm.multimodal import MULTIMODAL_REGISTRY

17 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

18 MultiModalKwargsItems)

@@ -464,10 +463,8 @@ class LlavaNextVideoForConditionalGeneration(nn.Module, SupportsMultiModal,

463 def compute_logits(

464 self,

465 hidden_states: torch.Tensor,

467 - sampling_metadata: SamplingMetadata,

466 ) -> Optional[torch.Tensor]:

469 - return self.language_model.compute_logits(hidden_states,

470 - sampling_metadata)

467 + return self.language_model.compute_logits(hidden_states)

468

469 def load_weights(self, weights: Iterable[tuple[str,

470 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/llava_onevision.py

+1 -4

@@ -14,7 +14,6 @@ from transformers.models.llava_onevision.modeling_llava_onevision import (

14

15 from vllm.config import VllmConfig

16 from vllm.model_executor.layers.activation import get_act_fn

17 -from vllm.model_executor.sampling_metadata import SamplingMetadata

17 from vllm.multimodal import MULTIMODAL_REGISTRY

18 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

19 MultiModalKwargsItems)

@@ -934,10 +933,8 @@ class LlavaOnevisionForConditionalGeneration(nn.Module, SupportsMultiModal,

933 def compute_logits(

934 self,

935 hidden_states: torch.Tensor,

937 - sampling_metadata: SamplingMetadata,

936 ) -> Optional[torch.Tensor]:

939 - return self.language_model.compute_logits(hidden_states,

940 - sampling_metadata)

937 + return self.language_model.compute_logits(hidden_states)

938

939 def load_weights(self, weights: Iterable[tuple[str,

940 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/mamba.py

+2 -5

@@ -26,7 +26,6 @@ from vllm.model_executor.models.interfaces import (HasInnerState,

26 IsAttentionFree, SupportsPP)

27 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

28 MambaCacheParams)

29 -from vllm.model_executor.sampling_metadata import SamplingMetadata

29 from vllm.sequence import IntermediateTensors

30 from vllm.utils import LayerBlockType

31

@@ -299,10 +298,8 @@ class MambaForCausalLM(nn.Module, HasInnerState, IsAttentionFree, SupportsPP):

298 def get_seqlen_agnostic_capture_inputs(self, batch_size: int):

299 return self.mamba_cache.get_seqlen_agnostic_capture_inputs(batch_size)

300

302 - def compute_logits(self, hidden_states: torch.Tensor,

303 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

304 - logits = self.logits_processor(self.lm_head, hidden_states,

305 - sampling_metadata)

301 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

302 + logits = self.logits_processor(self.lm_head, hidden_states)

303 return logits

304

305 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/mamba2.py

+2 -5

@@ -30,7 +30,6 @@ from vllm.model_executor.models.interfaces import (HasInnerState,

30 IsAttentionFree)

31 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

32 MambaCacheParams)

33 -from vllm.model_executor.sampling_metadata import SamplingMetadata

33 from vllm.sequence import IntermediateTensors

34 from vllm.utils import LayerBlockType

35

@@ -335,10 +334,8 @@ class Mamba2ForCausalLM(nn.Module, HasInnerState, IsAttentionFree):

334 def get_seqlen_agnostic_capture_inputs(self, batch_size: int):

335 return self.mamba_cache.get_seqlen_agnostic_capture_inputs(batch_size)

336

338 - def compute_logits(self, hidden_states: torch.Tensor,

339 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

340 - logits = self.logits_processor(self.lm_head, hidden_states,

341 - sampling_metadata)

337 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

338 + logits = self.logits_processor(self.lm_head, hidden_states)

339 return logits

340

341 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/medusa.py

+1 -2

@@ -104,12 +104,11 @@ class Medusa(nn.Module):

104 def compute_logits(

105 self,

106 hidden_states: list[torch.Tensor],

107 - sampling_metadata,

107 ) -> list[torch.Tensor]:

108 logits_lst: list[torch.Tensor] = []

109

110 for hs, lm_head in zip(hidden_states, self.lm_heads):

112 - _logits = self.logits_processor(lm_head, hs, sampling_metadata)

111 + _logits = self.logits_processor(lm_head, hs)

112

113 if _logits is None:

114 # _logits should only be None on rank > 0, in which case

vllm/model_executor/models/midashenglm.py

+1 -3

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

42 RowParallelLinear)

43 from vllm.model_executor.layers.quantization import QuantizationConfig

44 from vllm.model_executor.model_loader.utils import set_default_torch_dtype

45 -from vllm.model_executor.sampling_metadata import SamplingMetadata

45 from vllm.multimodal import MULTIMODAL_REGISTRY

46 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

47 MultiModalKwargsItems)

@@ -784,9 +783,8 @@ class MiDashengLMModel(nn.Module, SupportsMultiModal, SupportsPP):

783 def compute_logits(

784 self,

785 hidden_states: torch.Tensor,

787 - sampling_metadata: SamplingMetadata,

786 ) -> Optional[torch.Tensor]:

789 - return self.decoder.compute_logits(hidden_states, sampling_metadata)

787 + return self.decoder.compute_logits(hidden_states)

788

789 def load_weights(self, weights: Iterable[tuple[str,

790 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/mimo.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

41 from vllm.model_executor.model_loader.weight_utils import (

42 default_weight_loader, maybe_remap_kv_scale_name)

43 from vllm.model_executor.models.qwen2 import Qwen2ForCausalLM, Qwen2Model

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .utils import PPMissingLayer, is_pp_missing_parameter, maybe_prefix

@@ -183,9 +182,7 @@ class MiMoForCausalLM(Qwen2ForCausalLM, nn.Module):

182 def compute_logits(

183 self,

184 hidden_states: torch.Tensor,

186 - sampling_metadata: SamplingMetadata,

185 ) -> Optional[torch.Tensor]:

186 hidden_states = self.model.norm(hidden_states)

189 - logits = self.logits_processor(self.lm_head, hidden_states,

190 - sampling_metadata)

187 + logits = self.logits_processor(self.lm_head, hidden_states)

188 return logits

vllm/model_executor/models/mimo_mtp.py

+2 -6

@@ -34,7 +34,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

34 ParallelLMHead, VocabParallelEmbedding)

35 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

36 from vllm.model_executor.models.qwen2 import Qwen2DecoderLayer

37 -from vllm.model_executor.sampling_metadata import SamplingMetadata

37 from vllm.sequence import IntermediateTensors

38

39 from .utils import maybe_prefix

@@ -140,12 +139,10 @@ class MiMoMultiTokenPredictor(nn.Module):

139 self,

140 hidden_states: torch.Tensor,

141 lm_head: ParallelLMHead,

143 - sampling_metadata: SamplingMetadata,

142 spec_step_idx: int = 0,

143 ) -> torch.Tensor:

144 self.mtp_layers[str(self.mtp_start_layer_idx + spec_step_idx)]

147 - logits = self.logits_processor(lm_head, hidden_states,

148 - sampling_metadata)

145 + logits = self.logits_processor(lm_head, hidden_states)

146 return logits

147

148

@@ -178,11 +175,10 @@ class MiMoMTP(nn.Module):

175 def compute_logits(

176 self,

177 hidden_states: torch.Tensor,

181 - sampling_metadata: SamplingMetadata,

178 spec_step_idx: int = 0,

179 ) -> Optional[torch.Tensor]:

180 return self.model.compute_logits(hidden_states, self.lm_head,

185 - sampling_metadata, spec_step_idx)

181 + spec_step_idx)

182

183 def load_weights(self, weights: Iterable[tuple[str,

184 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/minicpm.py

+1 -4

@@ -51,7 +51,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

51 from vllm.model_executor.layers.vocab_parallel_embedding import (

52 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

53 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

54 -from vllm.model_executor.sampling_metadata import SamplingMetadata

54 from vllm.model_executor.utils import set_weight_attrs

55 from vllm.platforms import current_platform

56 from vllm.sequence import IntermediateTensors

@@ -583,10 +582,8 @@ class MiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

582 def compute_logits(

583 self,

584 hidden_states: torch.Tensor,

586 - sampling_metadata: SamplingMetadata,

585 ) -> Optional[torch.Tensor]:

588 - logits = self.logits_processor(self.lm_head, hidden_states,

589 - sampling_metadata)

586 + logits = self.logits_processor(self.lm_head, hidden_states)

587 return logits

588

589 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/minicpm_eagle.py

+1 -4

@@ -39,7 +39,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

39 from vllm.model_executor.layers.vocab_parallel_embedding import (

40 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

41 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

42 -from vllm.model_executor.sampling_metadata import SamplingMetadata

42 from vllm.sequence import IntermediateTensors

43

44 from .interfaces import SupportsLoRA, SupportsPP

@@ -376,10 +375,8 @@ class EagleMiniCPMForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

375 def compute_logits(

376 self,

377 hidden_states: torch.Tensor,

379 - sampling_metadata: SamplingMetadata,

378 ) -> Optional[torch.Tensor]:

381 - logits = self.logits_processor(self.lm_head, hidden_states,

382 - sampling_metadata)

379 + logits = self.logits_processor(self.lm_head, hidden_states)

380 return logits

381

382 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/minicpmv.py

+1 -3

@@ -50,7 +50,6 @@ from vllm.model_executor.models.minicpm import MiniCPMForCausalLM

50 from vllm.model_executor.models.module_mapping import MultiModelKeys

51 from vllm.model_executor.models.qwen2 import Qwen2ForCausalLM

52 from vllm.model_executor.models.qwen3 import Qwen3ForCausalLM

53 -from vllm.model_executor.sampling_metadata import SamplingMetadata

53 from vllm.multimodal import MULTIMODAL_REGISTRY

54 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

55 MultiModalKwargsItems, NestedTensors)

@@ -1194,9 +1193,8 @@ class MiniCPMVBaseModel(nn.Module, SupportsMultiModal, SupportsPP):

1193 def compute_logits(

1194 self,

1195 hidden_states: torch.Tensor,

1197 - sampling_metadata: SamplingMetadata,

1196 ) -> Optional[torch.Tensor]:

1199 - return self.llm.compute_logits(hidden_states, sampling_metadata)

1197 + return self.llm.compute_logits(hidden_states)

1198

1199 def load_weights(self, weights: Iterable[tuple[str,

1200 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/minimax_text_01.py

+2 -5

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

41 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

42 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

43 from vllm.model_executor.models.utils import maybe_prefix

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import HasInnerState, IsHybrid

@@ -742,10 +741,8 @@ class MiniMaxText01ForCausalLM(nn.Module, HasInnerState, IsHybrid):

741

742 return hidden_states

743

745 - def compute_logits(self, hidden_states: torch.Tensor,

746 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

747 - logits = self.logits_processor(self.lm_head, hidden_states.float(),

748 - sampling_metadata)

744 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

745 + logits = self.logits_processor(self.lm_head, hidden_states.float())

746

747 return logits

748

vllm/model_executor/models/minimax_vl_01.py

+1 -4

@@ -14,7 +14,6 @@ from vllm.model_executor.layers.activation import get_act_fn

14 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

15 RowParallelLinear)

16 from vllm.model_executor.layers.quantization import QuantizationConfig

17 -from vllm.model_executor.sampling_metadata import SamplingMetadata

17 from vllm.multimodal import MULTIMODAL_REGISTRY

18 from vllm.multimodal.inputs import MultiModalFieldConfig

19 from vllm.sequence import IntermediateTensors

@@ -420,10 +419,8 @@ class MiniMaxVL01ForConditionalGeneration(nn.Module, SupportsMultiModal,

419 def compute_logits(

420 self,

421 hidden_states: torch.Tensor,

423 - sampling_metadata: SamplingMetadata,

422 ) -> Optional[torch.Tensor]:

425 - return self.language_model.compute_logits(hidden_states,

426 - sampling_metadata)

423 + return self.language_model.compute_logits(hidden_states)

424

425 def load_weights(self, weights: Iterable[tuple[str,

426 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/mistral3.py

+1 -4

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

20 RowParallelLinear)

21 from vllm.model_executor.layers.quantization import QuantizationConfig

22 from vllm.model_executor.models.module_mapping import MultiModelKeys

23 -from vllm.model_executor.sampling_metadata import SamplingMetadata

23 from vllm.multimodal import MULTIMODAL_REGISTRY

24 from vllm.multimodal.cache import BaseMultiModalProcessorCache

25 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -606,10 +605,8 @@ class Mistral3ForConditionalGeneration(nn.Module, SupportsLoRA,

605 def compute_logits(

606 self,

607 hidden_states: torch.Tensor,

609 - sampling_metadata: SamplingMetadata,

608 ) -> Optional[torch.Tensor]:

611 - return self.language_model.compute_logits(hidden_states,

612 - sampling_metadata)

609 + return self.language_model.compute_logits(hidden_states)

610

611 def load_weights(self, weights: Iterable[tuple[str,

612 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/mixtral.py

+1 -4

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

49 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

50 from vllm.model_executor.model_loader.weight_utils import (

51 default_weight_loader, maybe_remap_kv_scale_name)

52 -from vllm.model_executor.sampling_metadata import SamplingMetadata

52 from vllm.sequence import IntermediateTensors

53

54 from .interfaces import MixtureOfExperts, SupportsLoRA, SupportsPP

@@ -594,10 +593,8 @@ class MixtralForCausalLM(nn.Module, SupportsLoRA, SupportsPP,

593 def compute_logits(

594 self,

595 hidden_states: torch.Tensor,

597 - sampling_metadata: SamplingMetadata,

596 ) -> Optional[torch.Tensor]:

599 - logits = self.logits_processor(self.lm_head, hidden_states,

600 - sampling_metadata)

597 + logits = self.logits_processor(self.lm_head, hidden_states)

598 return logits

599

600 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/mllama4.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.rotary_embedding import get_rope

42 from vllm.model_executor.model_loader.utils import initialize_model

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.multimodal import MULTIMODAL_REGISTRY

45 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

46 MultiModalKwargsItems, NestedTensors)

@@ -856,10 +855,8 @@ class Llama4ForConditionalGeneration(nn.Module, SupportsMultiModal,

855 def compute_logits(

856 self,

857 hidden_states: torch.Tensor,

859 - sampling_metadata: SamplingMetadata,

858 ) -> Optional[torch.Tensor]:

861 - return self.language_model.compute_logits(hidden_states,

862 - sampling_metadata)

859 + return self.language_model.compute_logits(hidden_states)

860

861 def separate_weights(

862 self,

vllm/model_executor/models/molmo.py

+2 -5

@@ -26,7 +26,6 @@ from vllm.distributed import (get_pp_group, get_tensor_model_parallel_rank,

26 get_tensor_model_parallel_world_size,

27 split_tensor_along_last_dim,

28 tensor_model_parallel_all_gather)

29 -from vllm.model_executor import SamplingMetadata

29 from vllm.model_executor.layers.activation import (MulAndSilu, QuickGELU,

30 SiluAndMul)

31 from vllm.model_executor.layers.layernorm import RMSNorm

@@ -1527,10 +1526,8 @@ class MolmoForCausalLM(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA,

1526

1527 return hidden_states

1528

1530 - def compute_logits(self, hidden_states: torch.Tensor,

1531 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

1532 - logits = self.logits_processor(self.lm_head, hidden_states,

1533 - sampling_metadata)

1529 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

1530 + logits = self.logits_processor(self.lm_head, hidden_states)

1531 return logits

1532

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

vllm/model_executor/models/mpt.py

+1 -4

@@ -25,7 +25,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

25 from vllm.model_executor.layers.vocab_parallel_embedding import (

26 VocabParallelEmbedding)

27 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

28 -from vllm.model_executor.sampling_metadata import SamplingMetadata

28 from vllm.sequence import IntermediateTensors

29

30 from .interfaces import SupportsPP

@@ -320,10 +319,8 @@ class MPTForCausalLM(nn.Module, SupportsPP):

319 def compute_logits(

320 self,

321 hidden_states: torch.Tensor,

323 - sampling_metadata: SamplingMetadata,

322 ) -> Optional[torch.Tensor]:

325 - logits = self.logits_processor(self.lm_head, hidden_states,

326 - sampling_metadata)

323 + logits = self.logits_processor(self.lm_head, hidden_states)

324 return logits

325

326 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/nano_nemotron_vl.py

+1 -4

@@ -37,7 +37,6 @@ from vllm.model_executor.models.utils import (flatten_bn,

37 init_vllm_registered_model,

38 maybe_prefix,

39 merge_multimodal_embeddings)

40 -from vllm.model_executor.sampling_metadata import SamplingMetadata

40 from vllm.multimodal import MULTIMODAL_REGISTRY

41 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

42 MultiModalKwargs, MultiModalKwargsItems,

@@ -1192,10 +1191,8 @@ class NemotronH_Nano_VL(nn.Module, HasInnerState, IsHybrid,

1191 def compute_logits(

1192 self,

1193 hidden_states: torch.Tensor,

1195 - sampling_metadata: SamplingMetadata,

1194 ) -> Optional[torch.Tensor]:

1197 - return self.language_model.compute_logits(hidden_states,

1198 - sampling_metadata)

1195 + return self.language_model.compute_logits(hidden_states)

1196

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

1198 adapter_dict = dict(self.mlp1.named_parameters())

vllm/model_executor/models/nemotron.py

+1 -4

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

45 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

46 from vllm.model_executor.model_loader.weight_utils import (

47 default_weight_loader, maybe_remap_kv_scale_name)

48 -from vllm.model_executor.sampling_metadata import SamplingMetadata

48 from vllm.sequence import IntermediateTensors

49 from vllm.transformers_utils.configs import NemotronConfig

50

@@ -498,10 +497,8 @@ class NemotronForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

497 def compute_logits(

498 self,

499 hidden_states: torch.Tensor,

501 - sampling_metadata: SamplingMetadata,

500 ) -> Optional[torch.Tensor]:

503 - logits = self.logits_processor(self.lm_head, hidden_states,

504 - sampling_metadata)

501 + logits = self.logits_processor(self.lm_head, hidden_states)

502 return logits

503

504 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/nemotron_h.py

+1 -4

@@ -54,7 +54,6 @@ from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

54 from vllm.model_executor.models.utils import (

55 AutoWeightsLoader, WeightsMapper, make_empty_intermediate_tensors_factory,

56 make_layers, maybe_prefix)

57 -from vllm.model_executor.sampling_metadata import SamplingMetadata

57 from vllm.sequence import IntermediateTensors

58 from vllm.transformers_utils.configs import NemotronHConfig

59 from vllm.utils import LayerBlockType

@@ -622,10 +621,8 @@ class NemotronHForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

621 def compute_logits(

622 self,

623 hidden_states: torch.Tensor,

625 - sampling_metadata: SamplingMetadata,

624 ) -> Optional[torch.Tensor]:

627 - logits = self.logits_processor(self.lm_head, hidden_states,

628 - sampling_metadata)

625 + logits = self.logits_processor(self.lm_head, hidden_states)

626 return logits

627

628 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/nemotron_nas.py

+1 -4

@@ -44,7 +44,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

44 from vllm.model_executor.model_loader.weight_utils import (

45 default_weight_loader, maybe_remap_kv_scale_name)

46 from vllm.model_executor.models.llama import LlamaAttention, LlamaMLP

47 -from vllm.model_executor.sampling_metadata import SamplingMetadata

47 from vllm.sequence import IntermediateTensors

48

49 from .interfaces import HasNoOps, SupportsLoRA, SupportsPP

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

467 def compute_logits(

468 self,

469 hidden_states: torch.Tensor,

471 - sampling_metadata: SamplingMetadata,

470 ) -> Optional[torch.Tensor]:

473 - logits = self.logits_processor(self.lm_head, hidden_states,

474 - sampling_metadata)

471 + logits = self.logits_processor(self.lm_head, hidden_states)

472 return logits

473

474 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/nemotron_vl.py

+1 -4

@@ -26,7 +26,6 @@ from vllm.model_executor.models.internvl import (

26 BaseInternVLProcessingInfo, InternVLImageEmbeddingInputs,

27 InternVLImageInputs, InternVLImagePixelInputs, InternVLProcessor)

28 from vllm.model_executor.models.module_mapping import MultiModelKeys

29 -from vllm.model_executor.sampling_metadata import SamplingMetadata

29 from vllm.multimodal import MULTIMODAL_REGISTRY

30 from vllm.multimodal.image import convert_image_mode

31 from vllm.multimodal.inputs import NestedTensors

@@ -632,10 +631,8 @@ class LlamaNemotronVLChatModel(nn.Module, SupportsMultiModal, SupportsPP,

631 def compute_logits(

632 self,

633 hidden_states: torch.Tensor,

635 - sampling_metadata: SamplingMetadata,

634 ) -> Optional[torch.Tensor]:

637 - return self.language_model.compute_logits(hidden_states,

638 - sampling_metadata)

635 + return self.language_model.compute_logits(hidden_states)

636

637 def load_weights(self, weights: Iterable[tuple[str,

638 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/olmo.py

+1 -4

@@ -45,7 +45,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

45 from vllm.model_executor.layers.vocab_parallel_embedding import (

46 ParallelLMHead, VocabParallelEmbedding)

47 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

48 -from vllm.model_executor.sampling_metadata import SamplingMetadata

48 from vllm.sequence import IntermediateTensors

49

50 from .interfaces import SupportsLoRA, SupportsPP

@@ -391,10 +390,8 @@ class OlmoForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

390 def compute_logits(

391 self,

392 hidden_states: torch.Tensor,

394 - sampling_metadata: SamplingMetadata,

393 ) -> Optional[torch.Tensor]:

396 - logits = self.logits_processor(self.lm_head, hidden_states,

397 - sampling_metadata)

394 + logits = self.logits_processor(self.lm_head, hidden_states)

395 return logits

396

397 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/olmo2.py

+1 -4

@@ -54,7 +54,6 @@ from vllm.model_executor.models.interfaces import SupportsLoRA, SupportsPP

54 from vllm.model_executor.models.utils import (

55 AutoWeightsLoader, extract_layer_index, is_pp_missing_parameter,

56 make_empty_intermediate_tensors_factory, make_layers, maybe_prefix)

57 -from vllm.model_executor.sampling_metadata import SamplingMetadata

57 from vllm.sequence import IntermediateTensors

58 from vllm.transformers_utils.configs import Olmo3Config

59

@@ -427,10 +426,8 @@ class Olmo2ForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

426 def compute_logits(

427 self,

428 hidden_states: torch.Tensor,

430 - sampling_metadata: SamplingMetadata,

429 ) -> Optional[torch.Tensor]:

432 - logits = self.logits_processor(self.lm_head, hidden_states,

433 - sampling_metadata)

430 + logits = self.logits_processor(self.lm_head, hidden_states)

431 return logits

432

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

vllm/model_executor/models/olmoe.py

+2 -5

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 ParallelLMHead, VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsPP

@@ -471,10 +470,8 @@ class OlmoeForCausalLM(nn.Module, SupportsPP):

470 inputs_embeds)

471 return hidden_states

472

474 - def compute_logits(self, hidden_states: torch.Tensor,

475 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

476 - logits = self.logits_processor(self.lm_head, hidden_states,

477 - sampling_metadata)

473 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

474 + logits = self.logits_processor(self.lm_head, hidden_states)

475 return logits

476

477 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/opt.py

+1 -4

@@ -41,7 +41,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

41 from vllm.model_executor.layers.vocab_parallel_embedding import (

42 ParallelLMHead, VocabParallelEmbedding)

43 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsPP

@@ -399,10 +398,8 @@ class OPTForCausalLM(nn.Module, SupportsPP):

398 def compute_logits(

399 self,

400 hidden_states: torch.Tensor,

402 - sampling_metadata: SamplingMetadata,

401 ) -> Optional[torch.Tensor]:

404 - logits = self.logits_processor(self.lm_head, hidden_states,

405 - sampling_metadata)

402 + logits = self.logits_processor(self.lm_head, hidden_states)

403 return logits

404

405 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/orion.py

+1 -4

@@ -28,7 +28,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

28 from vllm.model_executor.layers.vocab_parallel_embedding import (

29 ParallelLMHead, VocabParallelEmbedding)

30 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

31 -from vllm.model_executor.sampling_metadata import SamplingMetadata

31 from vllm.sequence import IntermediateTensors

32

33 from .interfaces import SupportsPP

@@ -339,10 +338,8 @@ class OrionForCausalLM(nn.Module, SupportsPP):

338 def compute_logits(

339 self,

340 hidden_states: torch.Tensor,

342 - sampling_metadata: SamplingMetadata,

341 ) -> Optional[torch.Tensor]:

344 - logits = self.logits_processor(self.lm_head, hidden_states,

345 - sampling_metadata)

342 + logits = self.logits_processor(self.lm_head, hidden_states)

343 return logits

344

345 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/ovis.py

+1 -3

@@ -39,7 +39,6 @@ from vllm.model_executor.models.siglip import SiglipVisionModel

39 from vllm.model_executor.models.utils import (AutoWeightsLoader, flatten_bn,

40 init_vllm_registered_model,

41 maybe_prefix)

42 -from vllm.model_executor.sampling_metadata import SamplingMetadata

42 from vllm.multimodal import MULTIMODAL_REGISTRY

43 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

44 MultiModalKwargsItems)

@@ -558,9 +557,8 @@ class Ovis(nn.Module, SupportsMultiModal, SupportsPP):

557 def compute_logits(

558 self,

559 hidden_states: torch.Tensor,

561 - sampling_metadata: SamplingMetadata,

560 ) -> Optional[torch.Tensor]:

563 - logits = self.llm.compute_logits(hidden_states, sampling_metadata)

561 + logits = self.llm.compute_logits(hidden_states)

562 return logits

563

564 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/ovis2_5.py

+1 -3

@@ -19,7 +19,6 @@ from vllm.model_executor.models.siglip2navit import Siglip2NavitModel

19 from vllm.model_executor.models.utils import (AutoWeightsLoader, flatten_bn,

20 init_vllm_registered_model,

21 maybe_prefix)

22 -from vllm.model_executor.sampling_metadata import SamplingMetadata

22 from vllm.multimodal import MULTIMODAL_REGISTRY

23 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

24 MultiModalKwargsItems)

@@ -630,9 +629,8 @@ class Ovis2_5(nn.Module, SupportsMultiModal, SupportsPP):

629 def compute_logits(

630 self,

631 hidden_states: torch.Tensor,

633 - sampling_metadata: SamplingMetadata,

632 ) -> Optional[torch.Tensor]:

635 - logits = self.llm.compute_logits(hidden_states, sampling_metadata)

633 + logits = self.llm.compute_logits(hidden_states)

634 return logits

635

636 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/paligemma.py

+1 -4

@@ -9,7 +9,6 @@ from transformers import BatchFeature, PaliGemmaConfig

9

10 from vllm.config import VllmConfig

11 from vllm.logger import init_logger

12 -from vllm.model_executor.sampling_metadata import SamplingMetadata

12 from vllm.multimodal import MULTIMODAL_REGISTRY

13 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

14 MultiModalInputs, MultiModalKwargsItems,

@@ -403,10 +402,8 @@ class PaliGemmaForConditionalGeneration(nn.Module, SupportsMultiModal,

402 def compute_logits(

403 self,

404 hidden_states: torch.Tensor,

406 - sampling_metadata: SamplingMetadata,

405 ) -> Optional[torch.Tensor]:

408 - return self.language_model.compute_logits(hidden_states,

409 - sampling_metadata)

406 + return self.language_model.compute_logits(hidden_states)

407

408 def load_weights(self, weights: Iterable[tuple[str,

409 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/persimmon.py

+1 -4

@@ -44,7 +44,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

44 from vllm.model_executor.layers.vocab_parallel_embedding import (

45 ParallelLMHead, VocabParallelEmbedding)

46 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

47 -from vllm.model_executor.sampling_metadata import SamplingMetadata

47 from vllm.sequence import IntermediateTensors

48

49 from .interfaces import SupportsPP

@@ -334,10 +333,8 @@ class PersimmonForCausalLM(nn.Module, SupportsPP):

333 def compute_logits(

334 self,

335 hidden_states: torch.Tensor,

337 - sampling_metadata: SamplingMetadata,

336 ) -> Optional[torch.Tensor]:

339 - logits = self.logits_processor(self.lm_head, hidden_states,

340 - sampling_metadata)

337 + logits = self.logits_processor(self.lm_head, hidden_states)

338 return logits

339

340 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/phi.py

+1 -3

@@ -59,7 +59,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

59 from vllm.model_executor.layers.vocab_parallel_embedding import (

60 ParallelLMHead, VocabParallelEmbedding)

61 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

62 -from vllm.model_executor.sampling_metadata import SamplingMetadata

62 from vllm.sequence import IntermediateTensors

63

64 from .interfaces import SupportsLoRA, SupportsPP

@@ -346,10 +345,9 @@ class PhiForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

345 def compute_logits(

346 self,

347 hidden_states: torch.Tensor,

349 - sampling_metadata: SamplingMetadata,

348 ) -> Optional[torch.Tensor]:

349 logits = self.logits_processor(self.lm_head, hidden_states,

352 - sampling_metadata, self.lm_head.bias)

350 + self.lm_head.bias)

351 return logits

352

353 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/phi3v.py

+1 -4

@@ -29,7 +29,6 @@ from vllm.logger import init_logger

29 from vllm.model_executor.layers.quantization import QuantizationConfig

30 from vllm.model_executor.layers.vocab_parallel_embedding import (

31 VocabParallelEmbedding)

32 -from vllm.model_executor.sampling_metadata import SamplingMetadata

32 from vllm.multimodal import MULTIMODAL_REGISTRY

33 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

34 MultiModalKwargsItems)

@@ -681,10 +680,8 @@ class Phi3VForCausalLM(nn.Module, SupportsMultiModal, SupportsPP,

680 def compute_logits(

681 self,

682 hidden_states: torch.Tensor,

684 - sampling_metadata: SamplingMetadata,

683 ) -> Optional[torch.Tensor]:

686 - return self.language_model.compute_logits(hidden_states,

687 - sampling_metadata)

684 + return self.language_model.compute_logits(hidden_states)

685

686 def load_weights(self, weights: Iterable[tuple[str,

687 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/phi4_multimodal.py

+1 -4

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

27 from vllm.model_executor.layers.quantization import QuantizationConfig

28 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

29 from vllm.model_executor.models.module_mapping import MultiModelKeys

30 -from vllm.model_executor.sampling_metadata import SamplingMetadata

30 from vllm.multimodal import MULTIMODAL_REGISTRY

31 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

32 MultiModalKwargsItems, NestedTensors)

@@ -1451,10 +1450,8 @@ class Phi4MultimodalForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

1450 def compute_logits(

1451 self,

1452 hidden_states: torch.Tensor,

1454 - sampling_metadata: SamplingMetadata,

1453 ) -> Optional[torch.Tensor]:

1456 - return self.language_model.compute_logits(hidden_states,

1457 - sampling_metadata)

1454 + return self.language_model.compute_logits(hidden_states)

1455

1456 def load_weights(self, weights: Iterable[tuple[str,

1457 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/phi4flash.py

-3

@@ -29,7 +29,6 @@ from vllm.model_executor.models.interfaces import (HasInnerState, IsHybrid,

29 SupportsV0Only)

30 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

31 MambaCacheParams)

32 -from vllm.model_executor.sampling_metadata import SamplingMetadata

32 from vllm.sequence import IntermediateTensors

33

34 from .utils import make_layers, maybe_prefix

@@ -695,12 +694,10 @@ class Phi4FlashForCausalLM(nn.Module, HasInnerState, IsHybrid, SupportsV0Only):

694 def compute_logits(

695 self,

696 hidden_states: torch.Tensor,

698 - sampling_metadata: SamplingMetadata,

697 ) -> Optional[torch.Tensor]:

698 processed_logits = self.logits_processor(

699 self.lm_head,

700 hidden_states,

703 - sampling_metadata,

701 self.embedding_bias,

702 )

703 return processed_logits

vllm/model_executor/models/phi4mm.py

+1 -4

@@ -18,7 +18,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

18 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead)

19 from vllm.model_executor.models.llama import LlamaModel

20 from vllm.model_executor.models.module_mapping import MultiModelKeys

21 -from vllm.model_executor.sampling_metadata import SamplingMetadata

21 from vllm.multimodal import MULTIMODAL_REGISTRY

22 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

23 MultiModalKwargsItems, NestedTensors)

@@ -1257,10 +1256,8 @@ class Phi4MMForCausalLM(nn.Module, SupportsLoRA, SupportsMultiModal):

1256 def compute_logits(

1257 self,

1258 hidden_states: torch.Tensor,

1260 - sampling_metadata: SamplingMetadata,

1259 ) -> Optional[torch.Tensor]:

1262 - logits = self.logits_processor(self.lm_head, hidden_states,

1263 - sampling_metadata)

1260 + logits = self.logits_processor(self.lm_head, hidden_states)

1261 return logits

1262

1263 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/phimoe.py

+2 -5

@@ -47,7 +47,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

47 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

48 from vllm.model_executor.model_loader.weight_utils import (

49 default_weight_loader, maybe_remap_kv_scale_name)

50 -from vllm.model_executor.sampling_metadata import SamplingMetadata

50 from vllm.sequence import IntermediateTensors

51

52 from .interfaces import SupportsLoRA, SupportsPP

@@ -667,10 +666,8 @@ class PhiMoEForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

666 inputs_embeds)

667 return hidden_states

668

670 - def compute_logits(self, hidden_states: torch.Tensor,

671 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

672 - logits = self.logits_processor(self.lm_head, hidden_states,

673 - sampling_metadata)

669 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

670 + logits = self.logits_processor(self.lm_head, hidden_states)

671 return logits

672

673 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/pixtral.py

+1 -4

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

32 RowParallelLinear)

33 from vllm.model_executor.layers.quantization import QuantizationConfig

34 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

35 -from vllm.model_executor.sampling_metadata import SamplingMetadata

35 from vllm.multimodal import MULTIMODAL_REGISTRY, MultiModalKwargsItems

36 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

37 MultiModalUUIDDict, NestedTensors)

@@ -480,10 +479,8 @@ class PixtralForConditionalGeneration(nn.Module, SupportsMultiModal,

479 def compute_logits(

480 self,

481 hidden_states: torch.Tensor,

483 - sampling_metadata: SamplingMetadata,

482 ) -> Optional[torch.Tensor]:

485 - return self.language_model.compute_logits(hidden_states,

486 - sampling_metadata)

483 + return self.language_model.compute_logits(hidden_states)

484

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

486

vllm/model_executor/models/plamo2.py

+1 -4

@@ -52,7 +52,6 @@ from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

52 from vllm.model_executor.models.utils import (

53 is_pp_missing_parameter, make_empty_intermediate_tensors_factory,

54 make_layers, maybe_prefix)

55 -from vllm.model_executor.sampling_metadata import SamplingMetadata

55 from vllm.model_executor.utils import set_weight_attrs

56 from vllm.platforms import current_platform

57 from vllm.sequence import IntermediateTensors

@@ -1022,10 +1021,8 @@ class Plamo2ForCausalLM(torch.nn.Module, HasInnerState, SupportsPP, IsHybrid):

1021 def compute_logits(

1022 self,

1023 hidden_states: torch.Tensor,

1025 - sampling_metadata: SamplingMetadata,

1024 ) -> Optional[torch.Tensor]:

1027 - logits = self.logits_processor(self.lm_head, hidden_states,

1028 - sampling_metadata)

1025 + logits = self.logits_processor(self.lm_head, hidden_states)

1026 return logits

1027

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

vllm/model_executor/models/qwen.py

+1 -4

@@ -30,7 +30,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

30 from vllm.model_executor.layers.vocab_parallel_embedding import (

31 ParallelLMHead, VocabParallelEmbedding)

32 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

33 -from vllm.model_executor.sampling_metadata import SamplingMetadata

33 from vllm.sequence import IntermediateTensors

34

35 from .interfaces import SupportsLoRA, SupportsPP

@@ -282,10 +281,8 @@ class QWenBaseModel(nn.Module):

281 def compute_logits(

282 self,

283 hidden_states: torch.Tensor,

285 - sampling_metadata: SamplingMetadata,

284 ) -> Optional[torch.Tensor]:

287 - logits = self.logits_processor(self.lm_head, hidden_states,

288 - sampling_metadata)

285 + logits = self.logits_processor(self.lm_head, hidden_states)

286 return logits

287

288 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/qwen2.py

+1 -4

@@ -49,7 +49,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

49 ParallelLMHead, VocabParallelEmbedding)

50 from vllm.model_executor.model_loader.weight_utils import (

51 default_weight_loader, maybe_remap_kv_scale_name)

52 -from vllm.model_executor.sampling_metadata import SamplingMetadata

52 from vllm.sequence import IntermediateTensors

53 from vllm.transformers_utils.config import is_interleaved

54

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

509 def compute_logits(

510 self,

511 hidden_states: torch.Tensor,

513 - sampling_metadata: SamplingMetadata,

512 ) -> Optional[torch.Tensor]:

515 - logits = self.logits_processor(self.lm_head, hidden_states,

516 - sampling_metadata)

513 + logits = self.logits_processor(self.lm_head, hidden_states)

514 return logits

515

516 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/qwen2_5_omni_thinker.py

+1 -4

@@ -50,7 +50,6 @@ from vllm.model_executor.models.qwen2_5_vl import (

50 from vllm.model_executor.models.qwen2_audio import (

51 Qwen2AudioProcessingInfo, _get_feat_extract_output_lengths)

52 from vllm.model_executor.models.qwen2_vl import Qwen2VLMultiModalDataParser

53 -from vllm.model_executor.sampling_metadata import SamplingMetadata

53 from vllm.multimodal import MULTIMODAL_REGISTRY

54 from vllm.multimodal.inputs import (ImageItem, ModalityData,

55 MultiModalDataDict, MultiModalFieldConfig,

@@ -955,10 +954,8 @@ class Qwen2_5OmniThinkerForConditionalGeneration(

954 def compute_logits(

955 self,

956 hidden_states: torch.Tensor,

958 - sampling_metadata: SamplingMetadata,

957 ) -> Optional[torch.Tensor]:

960 - return self.language_model.compute_logits(hidden_states,

961 - sampling_metadata)

958 + return self.language_model.compute_logits(hidden_states)

959

960 def load_weights(self, weights: Iterable[tuple[str,

961 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen2_5_vl.py

+1 -4

@@ -43,7 +43,6 @@ from vllm.config import VllmConfig

43 from vllm.distributed import parallel_state

44 from vllm.distributed import utils as dist_utils

45 from vllm.logger import init_logger

46 -from vllm.model_executor import SamplingMetadata

46 from vllm.model_executor.layers.activation import get_act_and_mul_fn

47 from vllm.model_executor.layers.layernorm import RMSNorm

48 # yapf: disable

@@ -1256,10 +1255,8 @@ class Qwen2_5_VLForConditionalGeneration(nn.Module, SupportsMultiModal,

1255 def compute_logits(

1256 self,

1257 hidden_states: torch.Tensor,

1259 - sampling_metadata: SamplingMetadata,

1258 ) -> Optional[torch.Tensor]:

1261 - return self.language_model.compute_logits(hidden_states,

1262 - sampling_metadata)

1259 + return self.language_model.compute_logits(hidden_states)

1260

1261 def load_weights(self, weights: Iterable[tuple[str,

1262 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen2_audio.py

+1 -4

@@ -34,7 +34,6 @@ from transformers.models.qwen2_audio import (Qwen2AudioConfig,

34 from transformers.models.whisper import WhisperFeatureExtractor

35

36 from vllm.config import VllmConfig

37 -from vllm.model_executor.sampling_metadata import SamplingMetadata

37 from vllm.multimodal import MULTIMODAL_REGISTRY

38 from vllm.multimodal.inputs import (AudioItem, ModalityData,

39 MultiModalDataDict, MultiModalFieldConfig,

@@ -481,10 +480,8 @@ class Qwen2AudioForConditionalGeneration(nn.Module, SupportsMultiModal,

480 def compute_logits(

481 self,

482 hidden_states: torch.Tensor,

484 - sampling_metadata: SamplingMetadata,

483 ) -> Optional[torch.Tensor]:

486 - return self.language_model.compute_logits(hidden_states,

487 - sampling_metadata)

484 + return self.language_model.compute_logits(hidden_states)

485

486 def load_weights(self, weights: Iterable[tuple[str,

487 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen2_moe.py

+1 -4

@@ -51,7 +51,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

51 from vllm.model_executor.layers.vocab_parallel_embedding import (

52 ParallelLMHead, VocabParallelEmbedding)

53 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

54 -from vllm.model_executor.sampling_metadata import SamplingMetadata

54 from vllm.sequence import IntermediateTensors

55

56 from .interfaces import SupportsLoRA, SupportsPP

@@ -546,10 +545,8 @@ class Qwen2MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA):

545 def compute_logits(

546 self,

547 hidden_states: torch.Tensor,

549 - sampling_metadata: SamplingMetadata,

548 ) -> Optional[torch.Tensor]:

551 - logits = self.logits_processor(self.lm_head, hidden_states,

552 - sampling_metadata)

549 + logits = self.logits_processor(self.lm_head, hidden_states)

550 return logits

551

552 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/qwen2_vl.py

+1 -4

@@ -46,7 +46,6 @@ from vllm.config import VllmConfig

46 from vllm.distributed import parallel_state, tensor_model_parallel_all_gather

47 from vllm.distributed import utils as dist_utils

48 from vllm.logger import init_logger

49 -from vllm.model_executor import SamplingMetadata

49 from vllm.model_executor.layers.activation import QuickGELU

50 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

51 RowParallelLinear)

@@ -1527,10 +1526,8 @@ class Qwen2VLForConditionalGeneration(nn.Module, SupportsMultiModal,

1526 def compute_logits(

1527 self,

1528 hidden_states: torch.Tensor,

1530 - sampling_metadata: SamplingMetadata,

1529 ) -> Optional[torch.Tensor]:

1532 - return self.language_model.compute_logits(hidden_states,

1533 - sampling_metadata)

1530 + return self.language_model.compute_logits(hidden_states)

1531

1532 def load_weights(self, weights: Iterable[tuple[str,

1533 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen3.py

+1 -4

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

41 from vllm.model_executor.layers.quantization import QuantizationConfig

42 from vllm.model_executor.layers.rotary_embedding import get_rope

43 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import SupportsEagle3, SupportsLoRA, SupportsPP

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

327 def compute_logits(

328 self,

329 hidden_states: torch.Tensor,

331 - sampling_metadata: SamplingMetadata,

330 ) -> Optional[torch.Tensor]:

333 - logits = self.logits_processor(self.lm_head, hidden_states,

334 - sampling_metadata)

331 + logits = self.logits_processor(self.lm_head, hidden_states)

332 return logits

333

334 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/qwen3_moe.py

+1 -4

@@ -54,7 +54,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

54 ParallelLMHead, VocabParallelEmbedding)

55 from vllm.model_executor.model_loader.weight_utils import (

56 default_weight_loader, maybe_remap_kv_scale_name)

57 -from vllm.model_executor.sampling_metadata import SamplingMetadata

57 from vllm.sequence import IntermediateTensors

58

59 from .interfaces import MixtureOfExperts, SupportsLoRA, SupportsPP

@@ -690,10 +689,8 @@ class Qwen3MoeForCausalLM(nn.Module, SupportsPP, SupportsLoRA,

689 def compute_logits(

690 self,

691 hidden_states: torch.Tensor,

693 - sampling_metadata: SamplingMetadata,

692 ) -> Optional[torch.Tensor]:

695 - logits = self.logits_processor(self.lm_head, hidden_states,

696 - sampling_metadata)

693 + logits = self.logits_processor(self.lm_head, hidden_states)

694 return logits

695

696 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/qwen3_next.py

+1 -4

@@ -53,7 +53,6 @@ from vllm.model_executor.model_loader.weight_utils import (

53 default_weight_loader, sharded_weight_loader)

54 from vllm.model_executor.models.mamba_cache import MambaCacheParams

55 from vllm.model_executor.models.qwen2_moe import Qwen2MoeMLP as Qwen3NextMLP

56 -from vllm.model_executor.sampling_metadata import SamplingMetadata

56 from vllm.model_executor.utils import set_weight_attrs

57 from vllm.platforms import current_platform

58 from vllm.sequence import IntermediateTensors

@@ -1208,10 +1207,8 @@ class Qwen3NextForCausalLM(nn.Module, HasInnerState, SupportsLoRA, SupportsPP,

1207 def compute_logits(

1208 self,

1209 hidden_states: torch.Tensor,

1211 - sampling_metadata: SamplingMetadata,

1210 ) -> Optional[torch.Tensor]:

1213 - return self.logits_processor(self.lm_head, hidden_states,

1214 - sampling_metadata)

1211 + return self.logits_processor(self.lm_head, hidden_states)

1212

1213 def load_weights(self, weights: Iterable[tuple[str,

1214 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen3_next_mtp.py

+1 -4

@@ -19,7 +19,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

19 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

20 from vllm.model_executor.models.qwen3_next import (Qwen3NextDecoderLayer,

21 Qwen3NextRMSNorm)

22 -from vllm.model_executor.sampling_metadata import SamplingMetadata

22 from vllm.sequence import IntermediateTensors

23 from vllm.transformers_utils.configs import Qwen3NextConfig

24

@@ -266,11 +265,9 @@ class Qwen3NextMTP(nn.Module, SupportsPP):

265 def compute_logits(

266 self,

267 hidden_states: torch.Tensor,

269 - sampling_metadata: SamplingMetadata,

268 spec_step_idx: int = 0,

269 ) -> Optional[torch.Tensor]:

272 - return self.logits_processor(self.lm_head, hidden_states,

273 - sampling_metadata)

270 + return self.logits_processor(self.lm_head, hidden_states)

271

272 def load_weights(self, weights: Iterable[tuple[str,

273 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/qwen3_vl.py

+1 -4

@@ -45,7 +45,6 @@ from vllm.compilation.decorators import support_torch_compile

45 from vllm.config import VllmConfig

46 from vllm.distributed import get_pp_group

47 from vllm.logger import init_logger

48 -from vllm.model_executor import SamplingMetadata

48 from vllm.model_executor.layers.activation import _ACTIVATION_REGISTRY

49 from vllm.model_executor.layers.linear import (ColumnParallelLinear,

50 RowParallelLinear)

@@ -1493,10 +1492,8 @@ class Qwen3VLForConditionalGeneration(nn.Module, SupportsMultiModal,

1492 def compute_logits(

1493 self,

1494 hidden_states: torch.Tensor,

1496 - sampling_metadata: SamplingMetadata,

1495 ) -> Optional[torch.Tensor]:

1498 - return self.language_model.compute_logits(hidden_states,

1499 - sampling_metadata)

1496 + return self.language_model.compute_logits(hidden_states)

1497

1498 def load_weights(self, weights: Iterable[tuple[str,

1499 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/seed_oss.py

+1 -4

@@ -47,7 +47,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

47 ParallelLMHead, VocabParallelEmbedding)

48 from vllm.model_executor.model_loader.weight_utils import (

49 default_weight_loader, maybe_remap_kv_scale_name)

50 -from vllm.model_executor.sampling_metadata import SamplingMetadata

50 from vllm.sequence import IntermediateTensors

51

52 from .interfaces import SupportsLoRA, SupportsPP

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

471 def compute_logits(

472 self,

473 hidden_states: torch.Tensor,

475 - sampling_metadata: SamplingMetadata,

474 ) -> Optional[torch.Tensor]:

477 - logits = self.logits_processor(self.lm_head, hidden_states,

478 - sampling_metadata)

475 + logits = self.logits_processor(self.lm_head, hidden_states)

476 return logits

477

478 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/skyworkr1v.py

+1 -4

@@ -22,7 +22,6 @@ from vllm.model_executor.layers.quantization import QuantizationConfig

22 from vllm.model_executor.layers.quantization.awq import AWQConfig

23 from vllm.model_executor.models.intern_vit import (InternVisionModel,

24 InternVisionPatchModel)

25 -from vllm.model_executor.sampling_metadata import SamplingMetadata

25 from vllm.multimodal import MULTIMODAL_REGISTRY

26 from vllm.multimodal.image import convert_image_mode

27 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

@@ -897,10 +896,8 @@ class SkyworkR1VChatModel(nn.Module, SupportsMultiModal, SupportsPP):

896 def compute_logits(

897 self,

898 hidden_states: torch.Tensor,

900 - sampling_metadata: SamplingMetadata,

899 ) -> Optional[torch.Tensor]:

902 - return self.language_model.compute_logits(hidden_states,

903 - sampling_metadata)

900 + return self.language_model.compute_logits(hidden_states)

901

902 def load_weights(self, weights: Iterable[tuple[str,

903 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/solar.py

+2 -5

@@ -47,7 +47,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

47 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

48 from vllm.model_executor.model_loader.weight_utils import (

49 default_weight_loader, maybe_remap_kv_scale_name)

50 -from vllm.model_executor.sampling_metadata import SamplingMetadata

50 from vllm.sequence import IntermediateTensors

51

52 from .interfaces import SupportsLoRA, SupportsPP

@@ -495,10 +494,8 @@ class SolarForCausalLM(nn.Module, SupportsLoRA, SupportsPP):

494 inputs_embeds)

495 return model_output

496

498 - def compute_logits(self, hidden_states: torch.Tensor,

499 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

500 - logits = self.logits_processor(self.lm_head, hidden_states,

501 - sampling_metadata)

497 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

498 + logits = self.logits_processor(self.lm_head, hidden_states)

499 return logits

500

501 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/stablelm.py

+1 -4

@@ -42,7 +42,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

42 from vllm.model_executor.layers.vocab_parallel_embedding import (

43 ParallelLMHead, VocabParallelEmbedding)

44 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

45 -from vllm.model_executor.sampling_metadata import SamplingMetadata

45 from vllm.sequence import IntermediateTensors

46

47 from .interfaces import SupportsPP

@@ -332,10 +331,8 @@ class StablelmForCausalLM(nn.Module, SupportsPP):

331 def compute_logits(

332 self,

333 hidden_states: torch.Tensor,

335 - sampling_metadata: SamplingMetadata,

334 ) -> Optional[torch.Tensor]:

337 - logits = self.logits_processor(self.lm_head, hidden_states,

338 - sampling_metadata)

335 + logits = self.logits_processor(self.lm_head, hidden_states)

336 return logits

337

338 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/starcoder2.py

+1 -4

@@ -43,7 +43,6 @@ from vllm.model_executor.layers.vocab_parallel_embedding import (

43 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

44 from vllm.model_executor.model_loader.weight_utils import (

45 default_weight_loader, maybe_remap_kv_scale_name)

46 -from vllm.model_executor.sampling_metadata import SamplingMetadata

46 from vllm.sequence import IntermediateTensors

47

48 from .interfaces import SupportsPP

@@ -339,10 +338,8 @@ class Starcoder2ForCausalLM(nn.Module, SupportsPP):

338 def compute_logits(

339 self,

340 hidden_states: torch.Tensor,

342 - sampling_metadata: SamplingMetadata,

341 ) -> Optional[torch.Tensor]:

344 - logits = self.logits_processor(self.lm_head, hidden_states,

345 - sampling_metadata)

342 + logits = self.logits_processor(self.lm_head, hidden_states)

343 return logits

344

345 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/step3_text.py

+2 -5

@@ -29,7 +29,6 @@ from vllm.model_executor.layers.rotary_embedding import get_rope

29 from vllm.model_executor.layers.vocab_parallel_embedding import (

30 DEFAULT_VOCAB_PADDING_SIZE, ParallelLMHead, VocabParallelEmbedding)

31 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

32 -from vllm.model_executor.sampling_metadata import SamplingMetadata

32 from vllm.sequence import IntermediateTensors

33

34 from .interfaces import SupportsPP

@@ -405,10 +404,8 @@ class Step3TextForCausalLM(nn.Module, SupportsPP):

404 inputs_embeds)

405 return hidden_states

406

408 - def compute_logits(self, hidden_states: torch.Tensor,

409 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

410 - logits = self.logits_processor(self.lm_head, hidden_states,

411 - sampling_metadata)

407 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

408 + logits = self.logits_processor(self.lm_head, hidden_states)

409 return logits

410

411 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/step3_vl.py

+1 -4

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

23 QKVParallelLinear,

24 RowParallelLinear)

25 from vllm.model_executor.layers.quantization import QuantizationConfig

26 -from vllm.model_executor.sampling_metadata import SamplingMetadata

26 from vllm.multimodal import MULTIMODAL_REGISTRY

27 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

28 MultiModalKwargsItems, NestedTensors)

@@ -1055,10 +1054,8 @@ class Step3VLForConditionalGeneration(nn.Module, SupportsMultiModal,

1054 def compute_logits(

1055 self,

1056 hidden_states: torch.Tensor,

1058 - sampling_metadata: SamplingMetadata,

1057 ) -> Optional[torch.Tensor]:

1060 - return self.language_model.compute_logits(hidden_states,

1061 - sampling_metadata)

1058 + return self.language_model.compute_logits(hidden_states)

1059

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

1061

vllm/model_executor/models/tarsier.py

+1 -4

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

23 RowParallelLinear)

24 from vllm.model_executor.layers.quantization import QuantizationConfig

25 from vllm.model_executor.models.llava import LlavaDummyInputsBuilder

26 -from vllm.model_executor.sampling_metadata import SamplingMetadata

26 from vllm.multimodal import MULTIMODAL_REGISTRY

27 from vllm.multimodal.cache import BaseMultiModalProcessorCache

28 from vllm.multimodal.inputs import MultiModalFieldConfig, MultiModalKwargsItems

@@ -638,10 +637,8 @@ class TarsierForConditionalGeneration(nn.Module, SupportsMultiModal,

637 def compute_logits(

638 self,

639 hidden_states: torch.Tensor,

641 - sampling_metadata: SamplingMetadata,

640 ) -> Optional[torch.Tensor]:

643 - return self.language_model.compute_logits(hidden_states,

644 - sampling_metadata)

641 + return self.language_model.compute_logits(hidden_states)

642

643 def load_weights(self, weights: Iterable[tuple[str,

644 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/transformers.py

+1 -4

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

41 from vllm.model_executor.layers.quantization import QuantizationConfig

42 from vllm.model_executor.layers.vocab_parallel_embedding import (

43 ParallelLMHead, VocabParallelEmbedding)

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.multimodal import MULTIMODAL_REGISTRY, MultiModalKwargsItems

45 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

46 MultiModalInputs, MultiModalUUIDDict,

@@ -798,10 +797,8 @@ class TransformersForCausalLM(TransformersBase):

797 def compute_logits(

798 self,

799 hidden_states: torch.Tensor,

801 - sampling_metadata: SamplingMetadata,

800 ) -> Optional[torch.Tensor]:

803 - logits = self.logits_processor(self.lm_head, hidden_states,

804 - sampling_metadata)

801 + logits = self.logits_processor(self.lm_head, hidden_states)

802 return logits

803

804

vllm/model_executor/models/ultravox.py

+2 -5

@@ -18,7 +18,6 @@ from vllm.model_executor.layers.activation import MulAndSilu, get_act_fn

18 from vllm.model_executor.layers.layernorm import RMSNorm

19 from vllm.model_executor.model_loader import DefaultModelLoader

20 from vllm.model_executor.models.module_mapping import MultiModelKeys

21 -from vllm.model_executor.sampling_metadata import SamplingMetadata

21 from vllm.multimodal import MULTIMODAL_REGISTRY

22 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

23 MultiModalKwargsItems, NestedTensors)

@@ -616,10 +615,8 @@ class UltravoxModel(nn.Module, SupportsMultiModal, SupportsPP, SupportsLoRA):

615 inputs_embeds=inputs_embeds)

616 return hidden_states

617

619 - def compute_logits(self, hidden_states: torch.Tensor,

620 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

621 - return self.language_model.compute_logits(hidden_states,

622 - sampling_metadata)

618 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

619 + return self.language_model.compute_logits(hidden_states)

620

621 def load_weights(self, weights: Iterable[tuple[str,

622 torch.Tensor]]) -> set[str]:

vllm/model_executor/models/voxtral.py

+1 -4

@@ -30,7 +30,6 @@ from vllm.model_executor.models.module_mapping import MultiModelKeys

30 # yapf: disable

31 from vllm.model_executor.models.whisper import WhisperEncoder

32 # yapf: enable

33 -from vllm.model_executor.sampling_metadata import SamplingMetadata

33 from vllm.multimodal import MULTIMODAL_REGISTRY

34 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

35 MultiModalKwargsItems, MultiModalUUIDDict,

@@ -454,10 +453,8 @@ class VoxtralForConditionalGeneration(nn.Module, SupportsMultiModal,

453 def compute_logits(

454 self,

455 hidden_states: torch.Tensor,

457 - sampling_metadata: SamplingMetadata,

456 ) -> Optional[torch.Tensor]:

459 - return self.language_model.compute_logits(hidden_states,

460 - sampling_metadata)

457 + return self.language_model.compute_logits(hidden_states)

458

459 @classmethod

460 def get_speech_to_text_config(cls, model_config: ModelConfig,

vllm/model_executor/models/whisper.py

+2 -5

@@ -31,7 +31,6 @@ from vllm.model_executor.layers.quantization.base_config import (

31 from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead

32 from vllm.model_executor.model_loader.utils import set_default_torch_dtype

33 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

34 -from vllm.model_executor.sampling_metadata import SamplingMetadata

34 from vllm.multimodal import MULTIMODAL_REGISTRY, NestedTensors

35 from vllm.multimodal.inputs import (MultiModalDataDict, MultiModalFieldConfig,

36 MultiModalKwargsItems)

@@ -936,10 +935,8 @@ class WhisperForConditionalGeneration(nn.Module, SupportsTranscription,

935

936 return WhisperAudioInputs(input_features=input_features)

937

939 - def compute_logits(self, hidden_states: torch.Tensor,

940 - sampling_metadata: SamplingMetadata) -> torch.Tensor:

941 - logits = self.logits_processor(self.proj_out, hidden_states,

942 - sampling_metadata)

938 + def compute_logits(self, hidden_states: torch.Tensor) -> torch.Tensor:

939 + logits = self.logits_processor(self.proj_out, hidden_states)

940 return logits

941

942 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/models/zamba2.py

+1 -4

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

41 from vllm.model_executor.model_loader.weight_utils import default_weight_loader

42 from vllm.model_executor.models.mamba_cache import (MambaCacheManager,

43 MambaCacheParams)

44 -from vllm.model_executor.sampling_metadata import SamplingMetadata

44 from vllm.sequence import IntermediateTensors

45

46 from .interfaces import HasInnerState, IsHybrid

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

1035 def compute_logits(

1036 self,

1037 hidden_states: torch.Tensor,

1039 - sampling_metadata: SamplingMetadata,

1038 ) -> Optional[torch.Tensor]:

1039 """Compute logits for next token prediction.

1040

@@ -1047,8 +1045,7 @@ class Zamba2ForCausalLM(nn.Module, HasInnerState, IsHybrid):

1045 Returns:

1046 Logits for next token prediction

1047 """

1050 - logits = self.logits_processor(self.lm_head, hidden_states,

1051 - sampling_metadata)

1048 + logits = self.logits_processor(self.lm_head, hidden_states)

1049 return logits

1050

1051 def load_weights(self, weights: Iterable[tuple[str,

vllm/model_executor/sampling_metadata.py deleted

-7

@@ -1,7 +0,0 @@

1 -# SPDX-License-Identifier: Apache-2.0

2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project

3 -

4 -

5 -class SamplingMetadata:

6 - # Placeholder until it can be safely removed.

7 - pass

vllm/v1/spec_decode/eagle.py

+3 -6

@@ -239,7 +239,7 @@ class EagleProposer:

239 else:

240 last_hidden_states, hidden_states = ret_hidden_states

241 sample_hidden_states = last_hidden_states[last_token_indices]

242 - logits = self.model.compute_logits(sample_hidden_states, None)

242 + logits = self.model.compute_logits(sample_hidden_states)

243

244 # Early exit if there is only one draft token to be generated.

245 if self.num_speculative_tokens == 1:

@@ -367,8 +367,7 @@ class EagleProposer:

367 else:

368 last_hidden_states, hidden_states = ret_hidden_states

369 hidden_states = hidden_states[:batch_size]

370 - logits = self.model.compute_logits(last_hidden_states[:batch_size],

371 - None)

370 + logits = self.model.compute_logits(last_hidden_states[:batch_size])

371 draft_token_ids = logits.argmax(dim=-1)

372 draft_token_ids_list.append(draft_token_ids)

373

@@ -678,9 +677,7 @@ class EagleProposer:

677 # Get the output logits for the draft tokens.

678 logits = self.model.compute_logits(

679 draft_last_hidden_states.reshape(batch_size * level_num_drafts,

681 - -1),

682 - None,

683 - )

680 + -1))

681

682 # Sample a draft token for each child at the next tree level.

683 num_children = self.child_drafts_per_level[level + 1]

vllm/v1/spec_decode/medusa.py

+1 -1

@@ -41,7 +41,7 @@ class MedusaProposer:

41 ) -> list[list[int]]:

42 # Generate blocks and compute logits

43 blocks = self.model(target_hidden_states)

44 - logits = self.model.compute_logits(blocks, None)

44 + logits = self.model.compute_logits(blocks)

45

46 # Get draft tokens and transpose the result

47 # TODO(woosuk): OPTIMIZATION: Return GPU tensor without GPU-CPU

vllm/v1/worker/gpu_model_runner.py

+4 -5

@@ -2240,7 +2240,7 @@ class GPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

2240 return output

2241

2242 sample_hidden_states = hidden_states[logits_indices]

2243 - logits = self.model.compute_logits(sample_hidden_states, None)

2243 + logits = self.model.compute_logits(sample_hidden_states)

2244 else:

2245 # Rare case.

2246 assert not self.is_pooling_model

@@ -2258,8 +2258,7 @@ class GPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

2258 logits = None

2259 else:

2260 sample_hidden_states = hidden_states[logits_indices]

2261 - logits = self.model.compute_logits(sample_hidden_states,

2262 - None)

2261 + logits = self.model.compute_logits(sample_hidden_states)

2262

2263 model_output_broadcast_data = {}

2264 if logits is not None:

@@ -2706,7 +2705,7 @@ class GPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

2705 req_idx = self.input_batch.req_id_to_index[req_id]

2706 offset = self.query_start_loc.np[req_idx].item()

2707 prompt_hidden_states = hidden_states[offset:offset + num_logits]

2709 - logits = self.model.compute_logits(prompt_hidden_states, None)

2708 + logits = self.model.compute_logits(prompt_hidden_states)

2709

2710 # Get the "target" tokens for each index. For prompt at index i,

2711 # the token at prompt index i+1 is the "sampled" token we want

@@ -3105,7 +3104,7 @@ class GPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

3104 # To avoid breaking the sampler, we use a random tensor here instead.

3105 hidden_states = torch.rand_like(hidden_states)

3106

3108 - logits = self.model.compute_logits(hidden_states, None)

3107 + logits = self.model.compute_logits(hidden_states)

3108 num_reqs = logits.size(0)

3109

3110 dummy_tensors = lambda v: torch.full(

vllm/v1/worker/tpu_model_runner.py

+1 -1

@@ -1692,7 +1692,7 @@ class TPUModelRunner(LoRAModelRunnerMixin, KVConnectorModelRunnerMixin):

1692 @torch.compile(backend="openxla", fullgraph=True, dynamic=False)

1693 def compute_logits(self,

1694 sample_hidden_states: torch.Tensor) -> torch.Tensor:

1695 - return self.model.compute_logits(sample_hidden_states, None)

1695 + return self.model.compute_logits(sample_hidden_states)

1696

1697 # TODO: Under SPMD mode, sample_from_logits has correctness issue.

1698 # Re-enable the torch.compile once the issue is fixed in torchxla.