| |
| import asyncio |
| import inspect |
| import os |
| import sglang as sgl |
| import torch |
| from copy import deepcopy |
| from PIL import Image |
| from sglang.srt.sampling.sampling_params import SamplingParams |
| from sglang.srt.server_args import ServerArgs |
| from transformers import GenerationConfig |
| from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union |
|
|
| from swift.metrics import Metric |
| from swift.model import get_processor |
| from swift.template import Template |
| from swift.utils import get_logger, safe_snapshot_download |
| from .infer_engine import InferEngine |
| from .protocol import (ChatCompletionResponse, ChatCompletionResponseChoice, ChatCompletionResponseStreamChoice, |
| ChatCompletionStreamResponse, ChatMessage, DeltaMessage, EmbeddingResponse, |
| EmbeddingResponseData, InferRequest, RequestConfig, random_uuid) |
| from .utils import InferStreamer |
|
|
| logger = get_logger() |
|
|
|
|
| class SglangEngine(InferEngine): |
|
|
| def __init__( |
| self, |
| model_id_or_path: str, |
| *, |
| template: Optional[Template] = None, |
| torch_dtype: Optional[torch.dtype] = None, |
| model_type: Optional[str] = None, |
| template_type: Optional[str] = None, |
| use_hf: Optional[bool] = None, |
| hub_token: Optional[str] = None, |
| revision: Optional[str] = None, |
| |
| tp_size: int = 1, |
| pp_size: int = 1, |
| dp_size: int = 1, |
| ep_size: int = 1, |
| enable_ep_moe: bool = False, |
| mem_fraction_static: Optional[float] = None, |
| context_length: Optional[int] = None, |
| disable_cuda_graph: bool = False, |
| quantization: Optional[str] = None, |
| task_type: Optional[str] = None, |
| kv_cache_dtype: str = 'auto', |
| enable_dp_attention: bool = False, |
| disable_custom_all_reduce: bool = True, |
| speculative_algorithm: Optional[str] = None, |
| speculative_num_steps: Optional[int] = None, |
| speculative_eagle_topk: Optional[int] = None, |
| speculative_num_draft_tokens: Optional[int] = None, |
| log_level='error', |
| engine_kwargs: Optional[Dict[str, Any]] = None, |
| ): |
| self.model_id_or_path = model_id_or_path |
| self.torch_dtype = torch_dtype |
| self.model_type = model_type |
| self.use_hf = use_hf |
| self.hub_token = hub_token |
| self.revision = revision |
| self.tp_size = tp_size |
| self.pp_size = pp_size |
| self.dp_size = dp_size |
| self.ep_size = ep_size |
| self.enable_ep_moe = enable_ep_moe |
| self.mem_fraction_static = mem_fraction_static |
| self.context_length = context_length |
| self.disable_cuda_graph = disable_cuda_graph |
| self.quantization = quantization |
| self.task_type = task_type |
| self.kv_cache_dtype = kv_cache_dtype |
| self.enable_dp_attention = enable_dp_attention |
| self.disable_custom_all_reduce = disable_custom_all_reduce |
| self.speculative_algorithm = speculative_algorithm |
| self.speculative_num_steps = speculative_num_steps |
| self.speculative_eagle_topk = speculative_eagle_topk |
| self.speculative_num_draft_tokens = speculative_num_draft_tokens |
| self.log_level = log_level |
| if template is None: |
| processor = self._get_processor() |
| template = self._get_template(processor, template_type=template_type) |
| else: |
| safe_snapshot_download( |
| model_id_or_path, |
| revision=revision, |
| download_model=True, |
| use_hf=use_hf, |
| ignore_patterns=getattr(template.model_meta, 'ignore_patterns', None), |
| hub_token=hub_token) |
| super().__init__(template) |
| self._prepare_server_args(engine_kwargs) |
| self.engine = sgl.Engine(server_args=self.server_args) |
| self._load_generation_config() |
| if speculative_num_draft_tokens is not None: |
| self.max_tokens_offset = -speculative_num_draft_tokens |
|
|
| def _get_processor(self): |
| return get_processor( |
| model_id_or_path=self.model_id_or_path, |
| torch_dtype=self.torch_dtype, |
| download_model=True, |
| model_type=self.model_type, |
| use_hf=self.use_hf, |
| hub_token=self.hub_token, |
| revision=self.revision, |
| task_type=self.task_type) |
|
|
| def _prepare_server_args(self, engine_kwargs): |
| if engine_kwargs is None: |
| engine_kwargs = {} |
| if self.context_length is not None: |
| self.max_model_len = self.context_length |
| logger.info(f'Setting max_model_len: {self.context_length}') |
| if self.max_model_len is not None: |
| self.max_model_len -= 1 |
| parameters = inspect.signature(ServerArgs).parameters |
| if 'pp_size' in parameters: |
| engine_kwargs['pp_size'] = self.pp_size |
| if 'enable_ep_moe' in parameters: |
| engine_kwargs['enable_ep_moe'] = self.enable_ep_moe |
| self.server_args = ServerArgs( |
| model_path=self.model_dir, |
| dtype=self.model_info.torch_dtype, |
| tp_size=self.tp_size, |
| dp_size=self.dp_size, |
| ep_size=self.ep_size, |
| mem_fraction_static=self.mem_fraction_static, |
| context_length=self.context_length, |
| disable_cuda_graph=self.disable_cuda_graph, |
| quantization=self.quantization, |
| kv_cache_dtype=self.kv_cache_dtype, |
| enable_dp_attention=self.enable_dp_attention, |
| disable_custom_all_reduce=self.disable_custom_all_reduce, |
| speculative_algorithm=self.speculative_algorithm, |
| speculative_num_steps=self.speculative_num_steps, |
| speculative_eagle_topk=self.speculative_eagle_topk, |
| speculative_num_draft_tokens=self.speculative_num_draft_tokens, |
| log_level=self.log_level, |
| skip_tokenizer_init=True, |
| trust_remote_code=True, |
| **engine_kwargs, |
| ) |
| if self.task_type == 'embedding': |
| self.server_args.is_embedding = True |
|
|
| def _load_generation_config(self) -> None: |
| generation_config_path = os.path.join(self.model_dir, 'generation_config.json') |
| if os.path.isfile(generation_config_path): |
| generation_config = GenerationConfig.from_pretrained(self.model_dir) |
| else: |
| generation_config = GenerationConfig() |
| kwargs = generation_config.to_dict() |
| top_k = kwargs.get('top_k') |
| if top_k == 0: |
| kwargs['top_k'] = -1 |
|
|
| parameters = inspect.signature(SamplingParams).parameters |
| self.generation_config = {k: v for k, v in kwargs.items() if k in parameters and v is not None} |
|
|
| def _prepare_generation_config(self, request_config: RequestConfig) -> Dict[str, Any]: |
| kwargs = {'max_new_tokens': request_config.max_tokens} |
| for key in ['temperature', 'top_k', 'top_p', 'repetition_penalty']: |
| new_value = getattr(request_config, key) |
| if new_value is None: |
| kwargs[key] = self.generation_config.get(key) |
| else: |
| kwargs[key] = new_value |
| for key in ['n', 'frequency_penalty', 'presence_penalty']: |
| kwargs[key] = getattr(request_config, key) |
|
|
| return kwargs |
|
|
| def _add_stop_words(self, generation_config: Dict[str, Any], request_config: RequestConfig) -> None: |
| template_meta = self.template.template_meta |
| stop_words = (request_config.stop or []) + (self.generation_config.get('stop') or []) + template_meta.stop_words |
| generation_config['stop_token_ids'] = self._get_stop_token_ids(stop_words) |
|
|
| def _create_chat_completion_response(self, output, inputs, return_details: bool = False): |
| assert output is not None |
| meta_info = output['meta_info'] |
| usage_info = self._get_usage_info(meta_info['prompt_tokens'], meta_info['completion_tokens']) |
| response = self.template.decode(output['output_ids']) |
| toolcall = self._get_toolcall(response) |
| token_ids = output['output_ids'] if return_details else None |
| choice = ChatCompletionResponseChoice( |
| index=0, |
| message=ChatMessage(role='assistant', content=response, tool_calls=toolcall), |
| finish_reason=meta_info['finish_reason']['type'], |
| logprobs=None, |
| token_ids=token_ids) |
| prompt_token_ids = None |
| images_size = None |
| if return_details: |
| prompt_token_ids = output.get('prompt_token_ids') |
| images = inputs['template_inputs'].images |
| if all(isinstance(image, Image.Image) for image in images): |
| images_size = [image.size for image in images] |
| return ChatCompletionResponse( |
| model=self.model_name, |
| choices=[choice], |
| usage=usage_info, |
| id=random_uuid(), |
| prompt_token_ids=prompt_token_ids, |
| images_size=images_size) |
|
|
| def infer( |
| self, |
| infer_requests: List[InferRequest], |
| request_config: Optional[RequestConfig] = None, |
| metrics: Optional[List[Metric]] = None, |
| *, |
| use_tqdm: Optional[bool] = None, |
| ) -> List[Union[ChatCompletionResponse, Iterator[ChatCompletionStreamResponse]]]: |
| return super().infer(infer_requests, request_config, metrics, use_tqdm=use_tqdm) |
|
|
| async def infer_async(self, |
| infer_request: InferRequest, |
| request_config: Optional[RequestConfig] = None, |
| *, |
| pre_infer_hook=None, |
| **kwargs) -> Union[ChatCompletionResponse, AsyncIterator[ChatCompletionStreamResponse]]: |
| request_config = deepcopy(request_config or RequestConfig()) |
| self.template.set_mode('sglang') |
| loop = asyncio.get_running_loop() |
| with torch.inference_mode(): |
| inputs = await loop.run_in_executor(None, self.template.encode, infer_request, True) |
| if self.task_type == 'embedding': |
| inputs.pop('length', None) |
| self.set_default_max_tokens(request_config, inputs) |
| generation_config = self._prepare_generation_config(request_config) |
| self._add_stop_words(generation_config, request_config) |
| kwargs.update({'inputs': inputs, 'generation_config': generation_config, 'request_config': request_config}) |
| if pre_infer_hook: |
| kwargs = pre_infer_hook(kwargs) |
| if request_config.stream: |
| return self._infer_stream_async(**kwargs) |
| elif self.task_type == 'embedding': |
| kwargs.pop('generation_config', None) |
| return await self._infer_embedding_async(**kwargs) |
| else: |
| return await self._infer_full_async(**kwargs) |
|
|
| async def _infer_embedding_async(self, inputs: Dict[str, Any], **kwargs) -> EmbeddingResponse: |
| from sglang.srt.managers.io_struct import EmbeddingReqInput |
| obj = EmbeddingReqInput( |
| input_ids=inputs['input_ids'], image_data=inputs.get('images'), audio_data=inputs.get('audios')) |
| generator = self.engine.tokenizer_manager.generate_request(obj, None) |
| output = await generator.__anext__() |
| usage_info = self._get_usage_info(output['meta_info']['prompt_tokens'], 0) |
| return EmbeddingResponse( |
| model=self.model_name, |
| data=[EmbeddingResponseData(embedding=output['embedding'])], |
| usage=usage_info, |
| id=random_uuid()) |
|
|
| async def _infer_full_async(self, inputs: Dict[str, Any], generation_config: Dict[str, Any], |
| request_config: RequestConfig) -> ChatCompletionResponse: |
| engine_inputs = {k: v for k, v in inputs.items() if k != 'template_inputs'} |
| output = await self.engine.async_generate(**engine_inputs, sampling_params=generation_config) |
| output['prompt_token_ids'] = inputs['input_ids'] |
| return self._create_chat_completion_response(output, inputs, request_config.return_details) |
|
|
| async def _infer_stream_async(self, inputs: Dict[str, Any], generation_config: Dict[str, Any], |
| **kwargs) -> AsyncIterator[ChatCompletionStreamResponse]: |
| engine_inputs = {k: v for k, v in inputs.items() if k != 'template_inputs'} |
| result_generator = await self.engine.async_generate( |
| **engine_inputs, sampling_params=generation_config, stream=True) |
| infer_streamer = InferStreamer(self.template) |
| async for output in result_generator: |
| res = self._create_chat_completion_stream_response(output, infer_streamer) |
| if res is None: |
| continue |
| yield res |
|
|
| def _create_chat_completion_stream_response(self, output, infer_streamer) -> Optional[ChatCompletionStreamResponse]: |
| assert output is not None |
| meta_info = output['meta_info'] |
| finish_reason = meta_info['finish_reason'] |
| is_finished = finish_reason is not None |
| delta_text = infer_streamer.get_printable_text(output['output_ids'], is_finished) |
| if not delta_text and not is_finished: |
| return |
| toolcall = None |
| if is_finished: |
| finish_reason = finish_reason['type'] |
| toolcall = self._get_toolcall(self.template.decode(output['output_ids'])) |
| meta_info = output['meta_info'] |
| usage_info = self._get_usage_info(meta_info['prompt_tokens'], meta_info['completion_tokens']) |
| |
| choice = ChatCompletionResponseStreamChoice( |
| index=0, |
| delta=DeltaMessage(role='assistant', content=delta_text, tool_calls=toolcall), |
| finish_reason=finish_reason, |
| logprobs=None) |
| return ChatCompletionStreamResponse(model=self.model_name, choices=[choice], usage=usage_info) |
|
|
