sglang 0.5.3rc2__py3-none-any.whl → 0.5.4__py3-none-any.whl

sglang/srt/configs/deepseekvl2.py

@@ -1,5 +1,4 @@
 import math
-import os
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Tuple
 
@@ -12,6 +11,8 @@ from transformers import (
     ProcessorMixin,
 )
 
+from sglang.srt.configs.deepseek_ocr import BASE_SIZE, IMAGE_SIZE, MAX_CROPS, MIN_CROPS
+
 
 def select_best_resolution(image_size, candidate_resolutions):
     # used for cropping
@@ -62,6 +63,7 @@ class DictOutput(object):
 class VLChatProcessorOutput(DictOutput):
     input_ids: torch.LongTensor
     target_ids: torch.LongTensor
+    images_crop: torch.LongTensor
     pixel_values: (
         torch.Tensor
     )  # rename from "images" to "pixel_values" for compatibility
@@ -105,6 +107,68 @@ class ImageTransform(object):
         return x
 
 
+def find_closest_aspect_ratio(aspect_ratio, target_ratios, width, height, image_size):
+    best_ratio_diff = float("inf")
+    best_ratio = (1, 1)
+    area = width * height
+    for ratio in target_ratios:
+        target_aspect_ratio = ratio[0] / ratio[1]
+        ratio_diff = abs(aspect_ratio - target_aspect_ratio)
+        if ratio_diff < best_ratio_diff:
+            best_ratio_diff = ratio_diff
+            best_ratio = ratio
+        elif ratio_diff == best_ratio_diff:
+            if area > 0.5 * image_size * image_size * ratio[0] * ratio[1]:
+                best_ratio = ratio
+    return best_ratio
+
+
+def dynamic_preprocess(
+    image, min_num=MIN_CROPS, max_num=MAX_CROPS, image_size=640, use_thumbnail=False
+):
+    orig_width, orig_height = image.size
+    aspect_ratio = orig_width / orig_height
+
+    # calculate the existing image aspect ratio
+    target_ratios = set(
+        (i, j)
+        for n in range(min_num, max_num + 1)
+        for i in range(1, n + 1)
+        for j in range(1, n + 1)
+        if i * j <= max_num and i * j >= min_num
+    )
+    target_ratios = sorted(target_ratios, key=lambda x: x[0] * x[1])
+
+    # find the closest aspect ratio to the target
+    target_aspect_ratio = find_closest_aspect_ratio(
+        aspect_ratio, target_ratios, orig_width, orig_height, image_size
+    )
+
+    # calculate the target width and height
+    target_width = image_size * target_aspect_ratio[0]
+    target_height = image_size * target_aspect_ratio[1]
+    blocks = target_aspect_ratio[0] * target_aspect_ratio[1]
+
+    # resize the image
+    resized_img = image.resize((target_width, target_height))
+    processed_images = []
+    for i in range(blocks):
+        box = (
+            (i % (target_width // image_size)) * image_size,
+            (i // (target_width // image_size)) * image_size,
+            ((i % (target_width // image_size)) + 1) * image_size,
+            ((i // (target_width // image_size)) + 1) * image_size,
+        )
+        # split the image
+        split_img = resized_img.crop(box)
+        processed_images.append(split_img)
+    assert len(processed_images) == blocks
+    if use_thumbnail and len(processed_images) != 1:
+        thumbnail_img = image.resize((image_size, image_size))
+        processed_images.append(thumbnail_img)
+    return processed_images, target_aspect_ratio
+
+
 class DeepseekVLV2Processor(ProcessorMixin):
     tokenizer_class = ("LlamaTokenizer", "LlamaTokenizerFast")
     attributes = ["tokenizer"]
@@ -134,7 +198,7 @@ class DeepseekVLV2Processor(ProcessorMixin):
         self.image_std = image_std
         self.normalize = normalize
         self.downsample_ratio = downsample_ratio
-
+        self.base_size = BASE_SIZE
         self.image_transform = ImageTransform(
             mean=image_mean, std=image_std, normalize=normalize
         )
@@ -177,7 +241,7 @@ class DeepseekVLV2Processor(ProcessorMixin):
             **kwargs,
         )
 
-    def format_messages_v2(self, messages, pil_images, max_req_input_len=-1):
+    def format_messages_v2(self, messages: str, pil_images, max_req_input_len=-1):
         """play the role of format_messages_v2 and get_images_info in the last version"""
         tokenized_data = []
         masked_tokenized_data = []  # labels
@@ -187,35 +251,34 @@ class DeepseekVLV2Processor(ProcessorMixin):
 
         image_index = 0
         image_token_cnt = messages.count(self.image_token)
-        tokenized_str, images, seq_mask, spatial_crop = self.tokenize_with_images(
+        (
+            input_ids,
+            images,
+            images_crop,
+            seq_mask,
+            spatial_crop,
+            num_image_tokens,
+            image_shapes,
+        ) = self.tokenize_with_images(
             messages,
             pil_images[image_index : image_index + image_token_cnt],
             bos=True,
             eos=True,
             cropping=len(pil_images) <= 2,
-            max_req_input_len=max_req_input_len,
         )
 
         image_index = image_token_cnt
-        tokenized_data += tokenized_str
-        if self.mask_prompt:
-            masked_tokenized_data += [self.ignore_id] * len(tokenized_str)
-        else:
-            masked_tokenized_data += tokenized_str
         images_list += images
         images_seq_mask += seq_mask
-        images_spatial_crop += spatial_crop
-
-        assert len(tokenized_data) == len(
-            images_seq_mask
-        ), f"format_messages_v2: tokenized_str's length {len(tokenized_str)} is not equal to imags_seq_mask's length {len(images_seq_mask)}"
+        images_spatial_crop = spatial_crop
 
         return (
-            tokenized_data,
+            input_ids,
             masked_tokenized_data,
             images_list,
             images_seq_mask,
             images_spatial_crop,
+            images_crop,
         )
 
     @property
@@ -252,6 +315,7 @@ class DeepseekVLV2Processor(ProcessorMixin):
         inference_mode: bool = True,
         system_prompt: str = "",
         max_req_input_len: int = -1,
+        cropping: bool = True,
         **kwargs,
     ):
         """
@@ -275,47 +339,22 @@ class DeepseekVLV2Processor(ProcessorMixin):
                 - num_image_tokens (List[int]): the number of image tokens
         """
 
-        assert (
-            prompt is None or conversations is None
-        ), "prompt and conversations cannot be used at the same time."
-
+        prompt = conversations or prompt
         (
-            tokenized_str,
+            input_ids,
             masked_tokenized_str,
             images_list,
             images_seq_mask,
             images_spatial_crop,
-        ) = self.format_messages_v2(conversations, images, max_req_input_len)
+            images_crop,
+        ) = self.format_messages_v2(prompt, images, max_req_input_len)
 
-        assert (
-            len(tokenized_str) == len(images_seq_mask) == len(masked_tokenized_str)
-        ), (
-            f"tokenized_str's length {len(tokenized_str)}, input_ids' length {len(masked_tokenized_str)}, "
-            f"imags_seq_mask's length {len(images_seq_mask)}, are not equal"
-        )
-
-        input_ids = torch.LongTensor(tokenized_str)
         target_ids = torch.LongTensor(masked_tokenized_str)
-        images_seq_mask = torch.tensor(images_seq_mask, dtype=torch.bool)
-
-        # set input_ids < 0 | input_ids == self.image_token_id as ignore_id
-        target_ids[(input_ids < 0) | (input_ids == self.image_token_id)] = (
-            self.ignore_id
-        )
-        input_ids[input_ids < 0] = self.pad_id
-
-        if inference_mode:
-            assert input_ids[-1] == self.eos_id
-            input_ids = input_ids[:-1]
-            target_ids = target_ids[:-1]
-            images_seq_mask = images_seq_mask[:-1]
 
         if len(images_list) == 0:
             images = torch.zeros((1, 3, self.image_size, self.image_size))
-            images_spatial_crop = torch.zeros((1, 2), dtype=torch.long)
         else:
             images = torch.stack(images_list, dim=0)
-            images_spatial_crop = torch.tensor(images_spatial_crop, dtype=torch.long)
 
         images_spatial_crop = torch.stack(
             [images_spatial_crop], dim=0
@@ -324,6 +363,7 @@ class DeepseekVLV2Processor(ProcessorMixin):
         prepare = VLChatProcessorOutput(
             input_ids=input_ids,
             target_ids=target_ids,
+            images_crop=images_crop,
             pixel_values=images,
             images_seq_mask=images_seq_mask,
             images_spatial_crop=images_spatial_crop,
@@ -341,10 +381,14 @@ class DeepseekVLV2Processor(ProcessorMixin):
         inference_mode: bool = True,
         system_prompt: str = "",
         max_req_input_len: int = -1,
+        text: list[str] = None,
         **kwargs,
     ):
+        assert text is None or isinstance(text, list)
+        if text is not None:
+            text = text[0]
         prepare = self.process_one(
-            prompt=prompt,
+            prompt=prompt or text,
             conversations=conversations,
             images=images,
             apply_sft_format=apply_sft_format,
@@ -369,85 +413,83 @@ class DeepseekVLV2Processor(ProcessorMixin):
         bos: bool = True,
         eos: bool = True,
         cropping: bool = True,
-        max_req_input_len: int = -1,
     ):
         """Tokenize text with <image> tags."""
-        images_list, images_seq_mask, images_spatial_crop = [], [], []
+
+        conversation = conversation
+        assert conversation.count(self.image_token) == len(images)
         text_splits = conversation.split(self.image_token)
+        images_list, images_crop_list, images_seq_mask, images_spatial_crop = (
+            [],
+            [],
+            [],
+            [],
+        )
+        image_shapes = []
+        num_image_tokens = []
         tokenized_str = []
         for text_sep, image in zip(text_splits, images):
             """encode text_sep"""
             tokenized_sep = self.encode(text_sep, bos=False, eos=False)
+
             tokenized_str += tokenized_sep
             images_seq_mask += [False] * len(tokenized_sep)
 
-            """select best resolution for anyres"""
-            if cropping:
-                best_width, best_height = select_best_resolution(
-                    image.size, self.candidate_resolutions
-                )
+            image_shapes.append(image.size)
+
+            if image.size[0] <= 640 and image.size[1] <= 640:
+                crop_ratio = [1, 1]
             else:
-                best_width, best_height = self.image_size, self.image_size
-            # print(image.size, (best_width, best_height)) # check the select_best_resolutions func
+                if cropping:
+                    images_crop_raw, crop_ratio = dynamic_preprocess(
+                        image, image_size=IMAGE_SIZE
+                    )
+                else:
+                    crop_ratio = [1, 1]
 
             """process the global view"""
+            if self.image_size <= 640 and not cropping:
+                image = image.resize((self.image_size, self.image_size))
+
             global_view = ImageOps.pad(
                 image,
-                (self.image_size, self.image_size),
+                (self.base_size, self.base_size),
                 color=tuple(int(x * 255) for x in self.image_transform.mean),
             )
             images_list.append(self.image_transform(global_view))
 
-            """process the local views"""
-            local_view = ImageOps.pad(
-                image,
-                (best_width, best_height),
-                color=tuple(int(x * 255) for x in self.image_transform.mean),
-            )
-            for i in range(0, best_height, self.image_size):
-                for j in range(0, best_width, self.image_size):
-                    images_list.append(
-                        self.image_transform(
-                            local_view.crop(
-                                (j, i, j + self.image_size, i + self.image_size)
-                            )
-                        )
-                    )
-
-            """record height / width crop num"""
-            num_width_tiles, num_height_tiles = (
-                best_width // self.image_size,
-                best_height // self.image_size,
-            )
+            num_width_tiles, num_height_tiles = crop_ratio
             images_spatial_crop.append([num_width_tiles, num_height_tiles])
 
+            if num_width_tiles > 1 or num_height_tiles > 1:
+                for i in range(len(images_crop_raw)):
+                    images_crop_list.append(self.image_transform(images_crop_raw[i]))
+
             """add image tokens"""
-            h = w = math.ceil(
+            num_queries = math.ceil(
                 (self.image_size // self.patch_size) / self.downsample_ratio
             )
-            # global views tokens h * (w + 1), 1 is for line separator
-            tokenized_image = [self.image_token_id] * h * (w + 1)
-            # add a separator between global and local views
-            tokenized_image += [self.image_token_id]
-            # local views tokens, (num_height_tiles * h) * (num_width_tiles * w + 1)
-            tokenized_image += (
-                [self.image_token_id]
-                * (num_height_tiles * h)
-                * (num_width_tiles * w + 1)
+            num_queries_base = math.ceil(
+                (self.base_size // self.patch_size) / self.downsample_ratio
             )
 
+            tokenized_image = (
+                [self.image_token_id] * num_queries_base + [self.image_token_id]
+            ) * num_queries_base
+            tokenized_image += [self.image_token_id]
+            if num_width_tiles > 1 or num_height_tiles > 1:
+                tokenized_image += (
+                    [self.image_token_id] * (num_queries * num_width_tiles)
+                    + [self.image_token_id]
+                ) * (num_queries * num_height_tiles)
             tokenized_str += tokenized_image
+
             images_seq_mask += [True] * len(tokenized_image)
-            # print(width_crop_num, height_crop_num, len(tokenized_image)) # test the correctness of the number of image-related tokens
+            num_image_tokens.append(len(tokenized_image))
 
         """process the last text split"""
         tokenized_sep = self.encode(text_splits[-1], bos=False, eos=False)
-        # deal with video, limit with request len
-        if max_req_input_len > -1:
-            if max_req_input_len < len(tokenized_sep) + len(tokenized_str) - 1:
-                rest = max_req_input_len - len(tokenized_sep) - 1 - 1024
-                tokenized_str = tokenized_str[:rest]
-                images_seq_mask = images_seq_mask[:rest]
+
         tokenized_str += tokenized_sep
         images_seq_mask += [False] * len(tokenized_sep)
 
@@ -463,7 +505,64 @@ class DeepseekVLV2Processor(ProcessorMixin):
             images_seq_mask
         ), f"tokenize_with_images func: tokenized_str's length {len(tokenized_str)} is not equal to imags_seq_mask's length {len(images_seq_mask)}"
 
-        return tokenized_str, images_list, images_seq_mask, images_spatial_crop
+        masked_tokenized_str = []
+        for token_index in tokenized_str:
+            if token_index != self.image_token_id:
+                masked_tokenized_str.append(token_index)
+            else:
+                masked_tokenized_str.append(self.ignore_id)
+
+        assert (
+            len(tokenized_str) == len(images_seq_mask) == len(masked_tokenized_str)
+        ), (
+            f"tokenized_str's length {len(tokenized_str)}, input_ids' length {len(masked_tokenized_str)}, "
+            f"imags_seq_mask's length {len(images_seq_mask)}, are not equal"
+        )
+        input_ids = torch.LongTensor(tokenized_str)
+        target_ids = torch.LongTensor(masked_tokenized_str)
+        images_seq_mask = torch.tensor(images_seq_mask, dtype=torch.bool)
+
+        # set input_ids < 0 | input_ids == self.image_token_id as ignore_id
+        target_ids[(input_ids < 0) | (input_ids == self.image_token_id)] = (
+            self.ignore_id
+        )
+        input_ids[input_ids < 0] = self.pad_id
+
+        inference_mode = True
+
+        if inference_mode:
+            # Remove the ending eos token
+            assert input_ids[-1] == self.eos_id
+            input_ids = input_ids[:-1]
+            target_ids = target_ids[:-1]
+            images_seq_mask = images_seq_mask[:-1]
+
+        if len(images_list) == 0:
+            pixel_values = torch.zeros((1, 3, self.base_size, self.base_size))
+            images_spatial_crop = torch.zeros((1, 1), dtype=torch.long)
+            images_crop = torch.zeros(
+                (1, 3, self.image_size, self.image_size)
+            ).unsqueeze(0)
+        else:
+            pixel_values = torch.stack(images_list, dim=0)
+            images_spatial_crop = torch.tensor(images_spatial_crop, dtype=torch.long)
+            if images_crop_list:
+                images_crop = torch.stack(images_crop_list, dim=0).unsqueeze(0)
+            else:
+                images_crop = torch.zeros(
+                    (1, 3, self.image_size, self.image_size)
+                ).unsqueeze(0)
+
+        input_ids = input_ids.unsqueeze(0)
+        return (
+            input_ids,
+            pixel_values,
+            images_crop,
+            images_seq_mask,
+            images_spatial_crop,
+            num_image_tokens,
+            image_shapes,
+        )
 
 
 class DeepseekVL2VisionEncoderConfig(PretrainedConfig):
@@ -548,7 +647,6 @@ class DeepseekVL2MlpProjectorConfig(PretrainedConfig):
 
 
 class DeepseekV2Config(PretrainedConfig):
-
     model_type = "deepseek_v2"
     keys_to_ignore_at_inference = ["past_key_values"]
 

sglang/srt/configs/dots_vlm.py

@@ -1,10 +1,5 @@
-from typing import Any, List, Optional, Union
-
-from transformers import AutoProcessor, LlamaTokenizerFast, PretrainedConfig
-from transformers.feature_extraction_utils import BatchFeature
-from transformers.image_utils import ImageInput
-from transformers.processing_utils import ProcessingKwargs, Unpack
-from transformers.tokenization_utils_base import PreTokenizedInput, TextInput
+from transformers import AutoProcessor, PretrainedConfig
+from transformers.processing_utils import ProcessingKwargs
 
 try:
     from transformers import Qwen2_5_VLProcessor

sglang/srt/configs/falcon_h1.py

@@ -14,21 +14,12 @@
 # limitations under the License.
 """Falcon-H1 model configuration"""
 
-import enum
-import os
 
-import numpy as np
-import torch
 from transformers.configuration_utils import PretrainedConfig
-from transformers.modeling_rope_utils import rope_config_validation
 from transformers.utils import logging
 
-from sglang.srt.distributed.utils import divide
-from sglang.srt.layers.attention.mamba.mamba_utils import MambaStateShapeCalculator
-from sglang.srt.layers.dp_attention import (
-    get_attention_tp_size,
-    get_tensor_model_parallel_world_size,
-)
+from sglang.srt.configs.mamba_utils import Mamba2CacheParams, Mamba2StateShape
+from sglang.srt.layers.dp_attention import get_tensor_model_parallel_world_size
 
 logger = logging.get_logger(__name__)
 
@@ -214,7 +205,7 @@ class FalconH1Config(PretrainedConfig):
         self.rope_scaling = None
         self.rope_scaling = rope_scaling
         self.projectors_bias = projectors_bias
-        mamba_intermediate = (
+        self.mamba_intermediate = mamba_intermediate = (
             mamba_expand * hidden_size if mamba_d_ssm is None else mamba_d_ssm
         )
 
@@ -294,18 +285,6 @@ class FalconH1Config(PretrainedConfig):
     def layers_block_type(self):
         return ["falcon_h1" for i in range(self.num_hidden_layers)]
 
-    @property
-    def mamba_cache_per_req(self):
-        conv_state_shape, temporal_state_shape, conv_dtype, ssm_dtype, mamba_layers = (
-            self.hybrid_gdn_params
-        )
-        mamba_layers_len = len(mamba_layers)
-
-        return (
-            int(np.prod(conv_state_shape)) * conv_dtype.itemsize
-            + int(np.prod(temporal_state_shape)) * ssm_dtype.itemsize
-        ) * mamba_layers_len
-
     @property
     def full_attention_layer_ids(self):
         # For Falcon-H1, we do have attention on all layers
@@ -317,44 +296,14 @@ class FalconH1Config(PretrainedConfig):
         return range(self.num_hidden_layers)
 
     @property
-    def hybrid_gdn_params(self):
-        world_size = get_tensor_model_parallel_world_size()
-
-        n_groups = self.mamba_n_groups
-        if self.mamba_n_groups % world_size != 0:
-            # - for TP we shard conv_dim by sharding on n_groups,
-            # - but if n_groups cannot divide tp_size, we need to
-            #   extend some extra groups
-            extra_groups = MambaStateShapeCalculator.extra_groups_for_head_shards(
-                self.mamba_n_groups, world_size
-            )
-            n_groups += extra_groups
-
-        conv_dim = self.mamba_d_ssm + 2 * n_groups * self.mamba_d_state
-
-        conv_state_shape = (
-            divide(conv_dim, world_size),
-            self.mamba_d_conv - 1,
-        )
-
-        # we TP-ize on the heads dimension
-        temporal_state_shape = (
-            self.mamba_d_state,
-            self.mamba_d_head,
-            divide(self.mamba_n_heads, world_size),
-        )
-        conv_dtype = torch.bfloat16
-        dtype_map = {
-            "float32": torch.float32,
-            "bfloat16": torch.bfloat16,
-        }
-        ssm_dtype = dtype_map[os.environ["SGLANG_MAMBA_SSM_DTYPE"]]
-        mamba_layers = self.linear_layer_ids
-
-        return (
-            conv_state_shape,
-            temporal_state_shape,
-            conv_dtype,
-            ssm_dtype,
-            mamba_layers,
+    def mamba2_cache_params(self):
+        shape = Mamba2StateShape.create(
+            tp_world_size=get_tensor_model_parallel_world_size(),
+            intermediate_size=self.mamba_intermediate,
+            n_groups=self.mamba_n_groups,
+            num_heads=self.mamba_n_heads,
+            head_dim=self.mamba_d_head,
+            state_size=self.mamba_d_state,
+            conv_kernel=self.mamba_d_conv,
         )
+        return Mamba2CacheParams(shape=shape, layers=self.linear_layer_ids)

sglang/srt/configs/load_config.py

@@ -1,10 +1,12 @@
 # Adapted from https://github.com/vllm-project/vllm/blob/v0.6.4.post1/vllm/config.py
 import enum
-import json
 import logging
 from dataclasses import dataclass, field
 from typing import List, Optional, Union
 
+import orjson
+
+from sglang.srt.configs.modelopt_config import ModelOptConfig
 from sglang.srt.utils import is_hip
 
 logger = logging.getLogger(__name__)
@@ -50,6 +52,11 @@ class LoadConfig:
     decryption_key_file: If set, decrypts the output files with a password read
         from this file (after PBKDF2).
     decrypt_max_concurrency: The maximum number of concurrent processes to decrypt the safetensor files. -1 means no limit.
+
+    # ModelOpt-specific loading options
+    modelopt_checkpoint_restore_path: Optional[str] = None
+    modelopt_checkpoint_save_path: Optional[str] = None
+    modelopt_export_path: Optional[str] = None
     """
 
     load_format: Union[str, LoadFormat] = LoadFormat.AUTO
@@ -63,10 +70,18 @@ class LoadConfig:
     remote_instance_weight_loader_seed_instance_service_port: Optional[int] = None
     remote_instance_weight_loader_send_weights_group_ports: Optional[List[int]] = None
 
+    # ModelOpt-specific loading options
+    modelopt_checkpoint_restore_path: Optional[str] = None
+    modelopt_checkpoint_save_path: Optional[str] = None
+    modelopt_export_path: Optional[str] = None
+
+    # ModelOpt configuration object
+    modelopt_config: Optional[ModelOptConfig] = None
+
     def __post_init__(self):
         model_loader_extra_config = self.model_loader_extra_config or {}
         if isinstance(model_loader_extra_config, str):
-            self.model_loader_extra_config = json.loads(model_loader_extra_config)
+            self.model_loader_extra_config = orjson.loads(model_loader_extra_config)
         self._verify_load_format()
 
         if self.ignore_patterns is not None and len(self.ignore_patterns) > 0:
@@ -77,6 +92,14 @@ class LoadConfig:
         else:
             self.ignore_patterns = ["original/**/*"]
 
+        # Create ModelOptConfig if not provided
+        if self.modelopt_config is None:
+            self.modelopt_config = ModelOptConfig(
+                checkpoint_restore_path=self.modelopt_checkpoint_restore_path,
+                checkpoint_save_path=self.modelopt_checkpoint_save_path,
+                export_path=self.modelopt_export_path,
+            )
+
     def _verify_load_format(self) -> None:
         if not isinstance(self.load_format, str):
             return