[V1] Avoid redundant input processing in n>1 case (#14985)

Signed-off-by: Nick Hill <nhill@redhat.com>

Author: njhill

tests/lora/test_tokenizer_group.py

@@ -24,12 +24,10 @@ async def test_tokenizer_group_lora(sql_lora_files, tokenizer_group_type):
     )
     lora_request = LoRARequest("1", 1, sql_lora_files)
     assert reference_tokenizer.encode("prompt") == tokenizer_group.encode(
-        request_id="request_id", prompt="prompt", lora_request=lora_request)
+        prompt="prompt", lora_request=lora_request)
     assert reference_tokenizer.encode(
         "prompt") == await tokenizer_group.encode_async(
-            request_id="request_id",
-            prompt="prompt",
-            lora_request=lora_request)
+            prompt="prompt", lora_request=lora_request)
     assert isinstance(tokenizer_group.get_lora_tokenizer(None),
                       PreTrainedTokenizerBase)
     assert tokenizer_group.get_lora_tokenizer(

tests/tokenization/test_tokenizer_group.py

@@ -41,10 +41,10 @@ async def test_tokenizer_group(tokenizer_group_type):
         max_input_length=None,
     )
     assert reference_tokenizer.encode("prompt") == tokenizer_group.encode(
-        request_id="request_id", prompt="prompt", lora_request=None)
+        prompt="prompt", lora_request=None)
     assert reference_tokenizer.encode(
-        "prompt") == await tokenizer_group.encode_async(
-            request_id="request_id", prompt="prompt", lora_request=None)
+        "prompt") == await tokenizer_group.encode_async(prompt="prompt",
+                                                        lora_request=None)
     assert isinstance(tokenizer_group.get_lora_tokenizer(None),
                       PreTrainedTokenizerBase)
     assert tokenizer_group.get_lora_tokenizer(
@@ -69,8 +69,7 @@ async def test_tokenizer_group_pool(tokenizer_group_type):
     # and check that all requests are processed correctly.
     num_requests = tokenizer_group_pool.pool_size * 5
     requests = [
-        tokenizer_group_pool.encode_async(request_id=str(i),
-                                          prompt=f"prompt {i}",
+        tokenizer_group_pool.encode_async(prompt=f"prompt {i}",
                                           lora_request=None)
         for i in range(num_requests)
     ]
@@ -161,12 +160,8 @@ class FailingRayTokenizerGroupPool(RayTokenizerGroupPool):
     fail_at[0] = 1000
 
     # We should recover successfully.
-    await tokenizer_group_pool.encode_async(request_id="1",
-                                            prompt="prompt",
-                                            lora_request=None)
-    await tokenizer_group_pool.encode_async(request_id="1",
-                                            prompt="prompt",
-                                            lora_request=None)
+    await tokenizer_group_pool.encode_async(prompt="prompt", lora_request=None)
+    await tokenizer_group_pool.encode_async(prompt="prompt", lora_request=None)
 
     # Check that we have a new actor
     assert len(tokenizer_group_pool.tokenizer_actors) == len(tokenizer_actors)
@@ -184,8 +179,7 @@ class FailingRayTokenizerGroupPool(RayTokenizerGroupPool):
 
     # We should fail after re-initialization.
     with pytest.raises(RuntimeError):
-        await tokenizer_group_pool.encode_async(request_id="1",
-                                                prompt="prompt",
+        await tokenizer_group_pool.encode_async(prompt="prompt",
                                                 lora_request=None)
 
     # check_health should raise the same thing
@@ -206,11 +200,8 @@ class FailingRayTokenizerGroupPool(RayTokenizerGroupPool):
 
     # Prompt too long error
     with pytest.raises(ValueError):
-        await tokenizer_group_pool.encode_async(request_id="1",
-                                                prompt="prompt" * 100,
+        await tokenizer_group_pool.encode_async(prompt="prompt" * 100,
                                                 lora_request=None)
-    await tokenizer_group_pool.encode_async(request_id="1",
-                                            prompt="prompt",
-                                            lora_request=None)
+    await tokenizer_group_pool.encode_async(prompt="prompt", lora_request=None)
     # Actors should stay the same.
     assert tokenizer_group_pool.tokenizer_actors == tokenizer_actors

vllm/engine/async_llm_engine.py

@@ -492,7 +492,6 @@ async def add_request_async(
 
         preprocessed_inputs = await self.input_preprocessor.preprocess_async(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             prompt_adapter_request=prompt_adapter_request,
         )

vllm/engine/llm_engine.py

@@ -783,7 +783,6 @@ def add_request(
 
         preprocessed_inputs = self.input_preprocessor.preprocess(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             prompt_adapter_request=prompt_adapter_request,
         )

vllm/engine/protocol.py

@@ -81,10 +81,7 @@ async def beam_search(
         if is_explicit_encoder_decoder_prompt(prompt):
             raise NotImplementedError
         else:
-            processed_inputs = preprocessor._prompt_to_llm_inputs(
-                prompt,
-                request_id=request_id,
-            )
+            processed_inputs = preprocessor._prompt_to_llm_inputs(prompt)
 
         prompt_token_ids = processed_inputs["prompt_token_ids"]
         prompt_text = processed_inputs.get("prompt")

vllm/inputs/preprocess.py

@@ -182,7 +182,6 @@ def _apply_prompt_adapter(
     def _tokenize_prompt(
         self,
         prompt: str,
-        request_id: str,
         lora_request: Optional[LoRARequest],
     ) -> list[int]:
         """
@@ -202,15 +201,13 @@ def _tokenize_prompt(
                     "do_lower_case", False)):
             prompt = prompt.lower()
 
-        return tokenizer.encode(request_id=request_id,
-                                prompt=prompt,
+        return tokenizer.encode(prompt=prompt,
                                 lora_request=lora_request,
                                 add_special_tokens=add_special_tokens)
 
     async def _tokenize_prompt_async(
         self,
         prompt: str,
-        request_id: str,
         lora_request: Optional[LoRARequest],
     ) -> list[int]:
         """Async version of :meth:`_tokenize_prompt`."""
@@ -222,7 +219,6 @@ async def _tokenize_prompt_async(
             # appending an EOS token to the prompt which disrupts generation.
             add_special_tokens = False
         return await tokenizer.encode_async(
-            request_id=request_id,
             prompt=prompt,
             lora_request=lora_request,
             add_special_tokens=add_special_tokens)
@@ -309,7 +305,6 @@ async def _process_multimodal_async(
     def _prompt_to_llm_inputs(
         self,
         prompt: SingletonPrompt,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         return_mm_hashes: bool = False,
     ) -> SingletonInputs:
@@ -318,7 +313,6 @@ def _prompt_to_llm_inputs(
 
         Arguments:
 
-        * request_id
         * prompt: single encoder or decoder input prompt
         * lora_request: this is only valid for decoder prompts
         * return_mm_hashes: whether to return multimodal hashes
@@ -333,7 +327,6 @@ def _prompt_to_llm_inputs(
             prompt_text = parsed["content"]
             prompt_token_ids = self._tokenize_prompt(
                 prompt_text,
-                request_id=request_id,
                 lora_request=lora_request,
             )
 
@@ -384,7 +377,6 @@ def _prompt_to_llm_inputs(
 
             prompt_token_ids = self._tokenize_prompt(
                 prompt_text,
-                request_id=request_id,
                 lora_request=lora_request,
             )
 
@@ -400,7 +392,6 @@ def _prompt_to_llm_inputs(
     async def _prompt_to_llm_inputs_async(
         self,
         prompt: SingletonPrompt,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         return_mm_hashes: bool = False,
     ) -> SingletonInputs:
@@ -411,7 +402,6 @@ async def _prompt_to_llm_inputs_async(
             prompt_text = parsed["content"]
             prompt_token_ids = await self._tokenize_prompt_async(
                 prompt_text,
-                request_id=request_id,
                 lora_request=lora_request,
             )
 
@@ -460,7 +450,6 @@ async def _prompt_to_llm_inputs_async(
 
             prompt_token_ids = await self._tokenize_prompt_async(
                 prompt_text,
-                request_id=request_id,
                 lora_request=lora_request,
             )
 
@@ -560,7 +549,6 @@ def _separate_enc_dec_inputs_from_mm_processor_outputs(
     def _process_encoder_decoder_prompt(
         self,
         prompt: PromptType,
-        request_id: str,
     ) -> EncoderDecoderInputs:
         """
         For encoder/decoder models only:
@@ -587,7 +575,6 @@ def _process_encoder_decoder_prompt(
         Arguments:
 
         * prompt: an input prompt
-        * request_id
 
         Returns:
 
@@ -598,16 +585,11 @@ def _process_encoder_decoder_prompt(
 
         if is_explicit_encoder_decoder_prompt(prompt):
             encoder_inputs = self._prompt_to_llm_inputs(
-                prompt["encoder_prompt"],
-                request_id=request_id,
-            )
+                prompt["encoder_prompt"])
             if (decoder_input := prompt["decoder_prompt"]) is None:
                 decoder_inputs = None
             else:
-                decoder_inputs = self._prompt_to_llm_inputs(
-                    decoder_input,
-                    request_id=request_id,
-                )
+                decoder_inputs = self._prompt_to_llm_inputs(decoder_input)
             # For multimodal model, override decoder prompt from processor
             # with explicit decoder prompt.
             if self.model_config.is_multimodal_model and (
@@ -616,10 +598,7 @@ def _process_encoder_decoder_prompt(
                     self._separate_enc_dec_inputs_from_mm_processor_outputs(
                         encoder_inputs, decoder_inputs))
         else:
-            inputs = self._prompt_to_llm_inputs(
-                prompt,
-                request_id=request_id,
-            )
+            inputs = self._prompt_to_llm_inputs(prompt)
             if self.model_config.is_multimodal_model and (
                     self._can_process_multimodal()):
                 # Encoder-Decoder Multimodal model
@@ -636,26 +615,20 @@ def _process_encoder_decoder_prompt(
     async def _process_encoder_decoder_prompt_async(
         self,
         prompt: PromptType,
-        request_id: str,
     ) -> EncoderDecoderInputs:
         """Async version of :meth:`_process_encoder_decoder_prompt`."""
         encoder_inputs: SingletonInputs
         decoder_inputs: Optional[SingletonInputs]
 
         if is_explicit_encoder_decoder_prompt(prompt):
             encoder_task = self._prompt_to_llm_inputs_async(
-                prompt["encoder_prompt"],
-                request_id=request_id,
-            )
+                prompt["encoder_prompt"])
 
             if (decoder_input := prompt["decoder_prompt"]) is None:
                 encoder_inputs = await encoder_task
                 decoder_inputs = None
             else:
-                decoder_task = self._prompt_to_llm_inputs_async(
-                    decoder_input,
-                    request_id=request_id,
-                )
+                decoder_task = self._prompt_to_llm_inputs_async(decoder_input)
 
                 encoder_inputs, decoder_inputs = await asyncio.gather(
                     encoder_task, decoder_task)
@@ -668,10 +641,7 @@ async def _process_encoder_decoder_prompt_async(
                     self._separate_enc_dec_inputs_from_mm_processor_outputs(
                         encoder_inputs, decoder_inputs))
         else:
-            inputs = await self._prompt_to_llm_inputs_async(
-                prompt,
-                request_id=request_id,
-            )
+            inputs = await self._prompt_to_llm_inputs_async(prompt)
             if self.model_config.is_multimodal_model and (
                     self._can_process_multimodal()):
                 # Encoder-Decoder Multimodal model
@@ -704,7 +674,6 @@ def _build_decoder_only_llm_inputs(
     def _process_decoder_only_prompt(
         self,
         prompt: SingletonPrompt,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         prompt_adapter_request: Optional[PromptAdapterRequest] = None,
         return_mm_hashes: bool = False,
@@ -716,7 +685,6 @@ def _process_decoder_only_prompt(
         Arguments:
 
         * prompt: input prompt
-        * request_id
         * lora_request
         * prompt_adapter_request
         * return_mm_hashes
@@ -728,7 +696,6 @@ def _process_decoder_only_prompt(
 
         prompt_comps = self._prompt_to_llm_inputs(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             return_mm_hashes=return_mm_hashes,
         )
@@ -741,15 +708,13 @@ def _process_decoder_only_prompt(
     async def _process_decoder_only_prompt_async(
         self,
         prompt: SingletonPrompt,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         prompt_adapter_request: Optional[PromptAdapterRequest] = None,
         return_mm_hashes: bool = False,
     ) -> DecoderOnlyInputs:
         """Async version of :meth:`_process_decoder_only_prompt`."""
         prompt_comps = await self._prompt_to_llm_inputs_async(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             return_mm_hashes=return_mm_hashes,
         )
@@ -762,7 +727,6 @@ async def _process_decoder_only_prompt_async(
     def preprocess(
         self,
         prompt: PromptType,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         prompt_adapter_request: Optional[PromptAdapterRequest] = None,
         return_mm_hashes: bool = False,
@@ -774,10 +738,7 @@ def preprocess(
                 "returned until they are supported on vLLM V1.")
             # Encoder-decoder model requires special mapping of
             # input prompts to encoder & decoder
-            return self._process_encoder_decoder_prompt(
-                prompt,
-                request_id=request_id,
-            )
+            return self._process_encoder_decoder_prompt(prompt)
 
         if is_explicit_encoder_decoder_prompt(prompt):
             raise ValueError("Cannot pass encoder-decoder prompt "
@@ -786,7 +747,6 @@ def preprocess(
         # Decoder-only operation
         return self._process_decoder_only_prompt(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             prompt_adapter_request=prompt_adapter_request,
             return_mm_hashes=return_mm_hashes,
@@ -795,7 +755,6 @@ def preprocess(
     async def preprocess_async(
         self,
         prompt: PromptType,
-        request_id: str,
         lora_request: Optional[LoRARequest] = None,
         prompt_adapter_request: Optional[PromptAdapterRequest] = None,
         return_mm_hashes: bool = False,
@@ -807,10 +766,7 @@ async def preprocess_async(
                 "returned until they are supported on vLLM V1.")
             # Encoder-decoder model requires special mapping of
             # input prompts to encoder & decoder
-            return await self._process_encoder_decoder_prompt_async(
-                prompt,
-                request_id=request_id,
-            )
+            return await self._process_encoder_decoder_prompt_async(prompt)
 
         if is_explicit_encoder_decoder_prompt(prompt):
             raise ValueError("Cannot pass encoder-decoder prompt "
@@ -819,7 +775,6 @@ async def preprocess_async(
         # Decoder-only operation
         return await self._process_decoder_only_prompt_async(
             prompt,
-            request_id=request_id,
             lora_request=lora_request,
             prompt_adapter_request=prompt_adapter_request,
             return_mm_hashes=return_mm_hashes,

vllm/transformers_utils/tokenizer_group/base_tokenizer_group.py

@@ -33,7 +33,6 @@ def get_max_input_len(
     @abstractmethod
     def encode(self,
                prompt: str,
-               request_id: Optional[str] = None,
                lora_request: Optional[LoRARequest] = None,
                add_special_tokens: Optional[bool] = None) -> List[int]:
         """Encode a prompt using the tokenizer group."""
@@ -43,7 +42,6 @@ def encode(self,
     async def encode_async(
             self,
             prompt: str,
-            request_id: Optional[str] = None,
             lora_request: Optional[LoRARequest] = None,
             add_special_tokens: Optional[bool] = None) -> List[int]:
         """Encode a prompt using the tokenizer group."""