serving_engine.py 8.49 KB
Newer Older
1
import json
2
from dataclasses import dataclass
3
from http import HTTPStatus
4
from typing import Any, Dict, List, Optional, Tuple, Union
5

6
7
from pydantic import Field
from typing_extensions import Annotated
8

9
from vllm.config import ModelConfig
10
from vllm.engine.async_llm_engine import AsyncLLMEngine
11
from vllm.entrypoints.openai.protocol import (ChatCompletionRequest,
12
                                              CompletionRequest,
13
                                              DetokenizeRequest,
14
                                              EmbeddingRequest, ErrorResponse,
15
                                              ModelCard, ModelList,
16
                                              ModelPermission, TokenizeRequest)
17
from vllm.logger import init_logger
18
from vllm.lora.request import LoRARequest
19
from vllm.sequence import Logprob
20
from vllm.transformers_utils.tokenizer import get_tokenizer
21
22
23
24

logger = init_logger(__name__)


25
@dataclass
26
class LoRAModulePath:
27
28
29
30
    name: str
    local_path: str


31
32
class OpenAIServing:

33
    def __init__(self, engine: AsyncLLMEngine, model_config: ModelConfig,
34
                 served_model_names: List[str],
35
36
37
                 lora_modules: Optional[List[LoRAModulePath]]):
        super().__init__()

38
        self.engine = engine
39
        self.model_config = model_config
40
41
42
43
44
45
46
47
48
49
        self.max_model_len = model_config.max_model_len

        # A separate tokenizer to map token IDs to strings.
        self.tokenizer = get_tokenizer(
            model_config.tokenizer,
            tokenizer_mode=model_config.tokenizer_mode,
            tokenizer_revision=model_config.tokenizer_revision,
            trust_remote_code=model_config.trust_remote_code,
            truncation_side="left")

50
        self.served_model_names = served_model_names
51

52
53
54
55
56
57
58
59
60
61
        if lora_modules is None:
            self.lora_requests = []
        else:
            self.lora_requests = [
                LoRARequest(
                    lora_name=lora.name,
                    lora_int_id=i,
                    lora_local_path=lora.local_path,
                ) for i, lora in enumerate(lora_modules, start=1)
            ]
62
63
64
65

    async def show_available_models(self) -> ModelList:
        """Show available models. Right now we only have one model."""
        model_cards = [
66
            ModelCard(id=served_model_name,
67
                      max_model_len=self.max_model_len,
68
                      root=self.served_model_names[0],
69
                      permission=[ModelPermission()])
70
            for served_model_name in self.served_model_names
71
        ]
72
73
        lora_cards = [
            ModelCard(id=lora.lora_name,
74
                      root=self.served_model_names[0],
75
76
77
78
                      permission=[ModelPermission()])
            for lora in self.lora_requests
        ]
        model_cards.extend(lora_cards)
79
80
81
82
83
84
85
86
87
88
89
        return ModelList(data=model_cards)

    def create_error_response(
            self,
            message: str,
            err_type: str = "BadRequestError",
            status_code: HTTPStatus = HTTPStatus.BAD_REQUEST) -> ErrorResponse:
        return ErrorResponse(message=message,
                             type=err_type,
                             code=status_code.value)

90
91
92
93
94
95
96
97
98
99
100
101
102
    def create_streaming_error_response(
            self,
            message: str,
            err_type: str = "BadRequestError",
            status_code: HTTPStatus = HTTPStatus.BAD_REQUEST) -> str:
        json_str = json.dumps({
            "error":
            self.create_error_response(message=message,
                                       err_type=err_type,
                                       status_code=status_code).model_dump()
        })
        return json_str

103
    async def _check_model(
104
105
106
        self, request: Union[ChatCompletionRequest, CompletionRequest,
                             DetokenizeRequest, EmbeddingRequest,
                             TokenizeRequest]
107
    ) -> Optional[ErrorResponse]:
108
        if request.model in self.served_model_names:
109
            return None
110
        if request.model in [lora.lora_name for lora in self.lora_requests]:
111
            return None
112
113
114
115
116
        return self.create_error_response(
            message=f"The model `{request.model}` does not exist.",
            err_type="NotFoundError",
            status_code=HTTPStatus.NOT_FOUND)

117
    def _maybe_get_lora(
118
119
        self, request: Union[CompletionRequest, ChatCompletionRequest,
                             EmbeddingRequest]
120
    ) -> Optional[LoRARequest]:
121
        if request.model in self.served_model_names:
122
            return None
123
124
125
126
        for lora in self.lora_requests:
            if request.model == lora.lora_name:
                return lora
        # if _check_model has been called earlier, this will be unreachable
127
        raise ValueError(f"The model `{request.model}` does not exist.")
128

129
    def _validate_prompt_and_tokenize(
130
131
            self,
            request: Union[ChatCompletionRequest, CompletionRequest,
132
133
                           DetokenizeRequest, EmbeddingRequest,
                           TokenizeRequest],
134
135
136
137
            prompt: Optional[str] = None,
            prompt_ids: Optional[List[int]] = None,
            truncate_prompt_tokens: Optional[Annotated[int,
                                                       Field(ge=1)]] = None,
138
139
            add_special_tokens: Optional[bool] = True
    ) -> Tuple[List[int], str]:
140
141
142
143
144
145
        if not (prompt or prompt_ids):
            raise ValueError("Either prompt or prompt_ids should be provided.")
        if (prompt and prompt_ids):
            raise ValueError(
                "Only one of prompt or prompt_ids should be provided.")

146
        if prompt_ids is None:
147
148
149
150
151
152
            # When using OpenAIServingChat for chat completions, for
            # most models the special tokens (e.g., BOS) have already
            # been added by the chat template. Therefore, we do not
            # need to add them again.
            # Set add_special_tokens to False (by default) to avoid
            # adding the BOS tokens again.
153
154
            tokenizer_kwargs: Dict[str, Any] = {
                "add_special_tokens": add_special_tokens
155
            }
156
157
158
159
160
            if truncate_prompt_tokens is not None:
                tokenizer_kwargs.update({
                    "truncation": True,
                    "max_length": truncate_prompt_tokens,
                })
161
162
163
164
165
166
            input_ids = self.tokenizer(prompt, **tokenizer_kwargs).input_ids
        elif truncate_prompt_tokens is not None:
            input_ids = prompt_ids[-truncate_prompt_tokens:]
        else:
            input_ids = prompt_ids

167
168
        input_text = prompt if prompt is not None else self.tokenizer.decode(
            prompt_ids)
169
170
        token_num = len(input_ids)

171
172
173
174
175
176
177
178
179
180
        # Note: EmbeddingRequest doesn't have max_tokens
        if isinstance(request, EmbeddingRequest):
            if token_num > self.max_model_len:
                raise ValueError(
                    f"This model's maximum context length is "
                    f"{self.max_model_len} tokens. However, you requested "
                    f"{token_num} tokens in the input for embedding "
                    f"generation. Please reduce the length of the input.", )
            return input_ids, input_text

181
182
183
184
185
        # Note: TokenizeRequest and DetokenizeRequest doesn't have max_tokens
        # and does not require model context length validation
        if isinstance(request, (TokenizeRequest, DetokenizeRequest)):
            return input_ids, input_text

186
        if request.max_tokens is None:
187
188
189
190
191
192
            if token_num >= self.max_model_len:
                raise ValueError(
                    f"This model's maximum context length is "
                    f"{self.max_model_len} tokens. However, you requested "
                    f"{token_num} tokens in the messages, "
                    f"Please reduce the length of the messages.", )
193
            request.max_tokens = self.max_model_len - token_num
194

195
        if token_num + request.max_tokens > self.max_model_len:
196
            raise ValueError(
197
198
199
                f"This model's maximum context length is "
                f"{self.max_model_len} tokens. However, you requested "
                f"{request.max_tokens + token_num} tokens "
200
201
202
203
                f"({token_num} in the messages, "
                f"{request.max_tokens} in the completion). "
                f"Please reduce the length of the messages or completion.", )
        else:
204
            return input_ids, input_text
205
206
207
208
209

    def _get_decoded_token(self, logprob: Logprob, token_id: int) -> str:
        if logprob.decoded_token is not None:
            return logprob.decoded_token
        return self.tokenizer.decode(token_id)