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

sglang/srt/layers/attention/mamba/mamba_utils.py

@@ -1,81 +0,0 @@
-# Adapted from: https://github.com/vllm-project/vllm/blob/main/vllm/model_executor/layers/mamba/mamba_utils.py
-from sglang.srt.distributed.utils import divide
-
-
-class MambaStateShapeCalculator:
-
-    @classmethod
-    def linear_attention_state_shape(
-        cls,
-        num_heads: int,
-        tp_size: int,
-        head_dim: int,
-    ) -> tuple[tuple[int, int, int], ...]:
-
-        state_shape = (num_heads // tp_size, head_dim, head_dim)
-        return (state_shape,)
-
-    @classmethod
-    def mamba1_state_shape(
-        cls,
-        tp_world_size: int,
-        intermediate_size: int,
-        state_size: int,
-        conv_kernel: int,
-    ) -> tuple[tuple[int, int], tuple[int, int]]:
-        conv_state_shape = (divide(intermediate_size, tp_world_size), conv_kernel - 1)
-
-        temporal_state_shape = (divide(intermediate_size, tp_world_size), state_size)
-
-        conv_state_shape = conv_state_shape[1], conv_state_shape[0]
-
-        return conv_state_shape, temporal_state_shape
-
-    @classmethod
-    def mamba2_state_shape(
-        cls,
-        tp_world_size: int,
-        intermediate_size: int,
-        n_groups: int,
-        num_heads: int,
-        head_dim: int,
-        state_size: int,
-        conv_kernel: int,
-    ) -> tuple[tuple[int, int], tuple[int, int, int]]:
-        # if n_groups is not divisible by world_size, need to extend the shards
-        # to ensure all groups needed by a head is sharded along with it
-        n_groups = n_groups + cls.extra_groups_for_head_shards(n_groups, tp_world_size)
-        # heads and n_groups are TP-ed
-        conv_dim = intermediate_size + 2 * n_groups * state_size
-
-        # contiguous along 'dim' axis
-        conv_state_shape = (conv_kernel - 1, divide(conv_dim, tp_world_size))
-
-        # These are not TP-ed as they depend on A, dt_bias, D
-        # - they are typically small
-        #   e.g., (h_heads, head_dim, state_size) = (128, 64, 128)
-        temporal_state_shape = (divide(num_heads, tp_world_size), head_dim, state_size)
-        return conv_state_shape, temporal_state_shape
-
-    @classmethod
-    def short_conv_state_shape(
-        cls,
-        tp_world_size: int,
-        intermediate_size: int,
-        conv_kernel: int,
-    ) -> tuple[tuple[int, int]]:
-        conv_dim = divide(intermediate_size, tp_world_size)
-        conv_state_shape = (conv_kernel - 1, conv_dim)
-        return (conv_state_shape,)
-
-    @classmethod
-    def extra_groups_for_head_shards(cls, ngroups: int, tp_size: int):
-        """Compute the increase in group numbers to account for
-        replication in order to accompany the head shards."""
-
-        # in the case ngoups % tp_size == 0, this will be zero
-        if ngroups % tp_size == 0:
-            return 0
-
-        # for n_groups == 1, this is exactly tp_size - n_groups
-        return tp_size - ngroups

sglang/srt/managers/tp_worker_overlap_thread.py

@@ -1,311 +0,0 @@
-# Copyright 2023-2024 SGLang Team
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""A tensor parallel worker."""
-from __future__ import annotations
-
-import dataclasses
-import logging
-import signal
-import threading
-from queue import Queue
-from typing import TYPE_CHECKING, List, Optional, Tuple
-
-import psutil
-import torch
-
-from sglang.srt.managers.io_struct import (
-    DestroyWeightsUpdateGroupReqInput,
-    GetWeightsByNameReqInput,
-    InitWeightsSendGroupForRemoteInstanceReqInput,
-    InitWeightsUpdateGroupReqInput,
-    LoadLoRAAdapterReqInput,
-    SendWeightsToRemoteInstanceReqInput,
-    UnloadLoRAAdapterReqInput,
-    UpdateWeightFromDiskReqInput,
-    UpdateWeightsFromDistributedReqInput,
-    UpdateWeightsFromTensorReqInput,
-)
-from sglang.srt.managers.overlap_utils import FutureMap
-from sglang.srt.managers.schedule_batch import ModelWorkerBatch
-from sglang.srt.managers.tp_worker import TpModelWorker
-from sglang.srt.model_executor.forward_batch_info import ForwardBatchOutput
-from sglang.srt.server_args import ServerArgs
-from sglang.srt.utils import DynamicGradMode
-from sglang.utils import get_exception_traceback
-
-if TYPE_CHECKING:
-    from sglang.srt.managers.cache_controller import LayerDoneCounter
-
-logger = logging.getLogger(__name__)
-
-
-class TpModelWorkerClient:
-    """A tensor parallel model worker."""
-
-    def __init__(
-        self,
-        server_args: ServerArgs,
-        gpu_id: int,
-        tp_rank: int,
-        moe_ep_rank: int,
-        pp_rank: int,
-        dp_rank: Optional[int],
-        nccl_port: int,
-    ):
-        # Load the model
-        self.worker = TpModelWorker(
-            server_args, gpu_id, tp_rank, moe_ep_rank, pp_rank, dp_rank, nccl_port
-        )
-        self.max_running_requests = self.worker.max_running_requests
-        self.device = self.worker.device
-        self.gpu_id = gpu_id
-
-        # Init future mappings
-        self.future_map = FutureMap(self.max_running_requests, self.device)
-
-        # Launch threads
-        self.input_queue = Queue[Tuple[ModelWorkerBatch, int, torch.Event]]()
-        self.output_queue = Queue()
-        self.forward_stream = torch.get_device_module(self.device).Stream()
-        self.forward_thread = threading.Thread(
-            target=self.forward_thread_func,
-        )
-        self.forward_thread.start()
-        self.parent_process = psutil.Process().parent()
-        self.scheduler_stream = torch.get_device_module(self.device).current_stream()
-        if self.device == "cpu":
-            self.scheduler_stream.synchronize = lambda: None  # No-op for CPU
-
-        self.hicache_layer_transfer_counter = None
-
-    def register_hicache_layer_transfer_counter(self, counter: LayerDoneCounter):
-        self.hicache_layer_transfer_counter = counter
-
-    def get_worker_info(self):
-        return self.worker.get_worker_info()
-
-    def get_tokens_per_layer_info(self):
-        return self.worker.get_tokens_per_layer_info()
-
-    @property
-    def sliding_window_size(self) -> Optional[int]:
-        return self.worker.sliding_window_size
-
-    @property
-    def is_hybrid(self) -> bool:
-        return self.worker.is_hybrid
-
-    def get_pad_input_ids_func(self):
-        return self.worker.get_pad_input_ids_func()
-
-    def get_tp_group(self):
-        return self.worker.get_tp_group()
-
-    def get_attention_tp_group(self):
-        return self.worker.get_attention_tp_group()
-
-    def get_attention_tp_cpu_group(self):
-        return self.worker.get_attention_tp_cpu_group()
-
-    def get_memory_pool(self):
-        return (
-            self.worker.model_runner.req_to_token_pool,
-            self.worker.model_runner.token_to_kv_pool_allocator,
-        )
-
-    def get_kv_cache(self):
-        return self.worker.model_runner.token_to_kv_pool
-
-    def forward_thread_func(self):
-        try:
-            with torch.get_device_module(self.device).stream(self.forward_stream):
-                self.forward_thread_func_()
-        except Exception:
-            traceback = get_exception_traceback()
-            logger.error(f"TpModelWorkerClient hit an exception: {traceback}")
-            self.parent_process.send_signal(signal.SIGQUIT)
-
-    @DynamicGradMode()
-    def forward_thread_func_(self):
-        batch_pt = 0
-        batch_lists: List = [None] * 2
-
-        while True:
-            model_worker_batch, future_map_ct, sync_event = self.input_queue.get()
-            if not model_worker_batch:
-                break
-
-            sync_event.wait()
-
-            # Keep a reference of model_worker_batch by storing it into a list.
-            # Otherwise, the tensor members of model_worker_batch will be released
-            # by pytorch and cause CUDA illegal memory access errors.
-            batch_lists[batch_pt % 2] = model_worker_batch
-            batch_pt += 1
-
-            # Create event
-            copy_done = torch.get_device_module(self.device).Event()
-
-            # Resolve future tokens in the input
-            self.future_map.resolve_future(model_worker_batch)
-
-            # Run forward
-            forward_batch_output = self.worker.forward_batch_generation(
-                model_worker_batch,
-                model_worker_batch.launch_done,
-            )
-
-            logits_output, next_token_ids, can_run_cuda_graph = (
-                forward_batch_output.logits_output,
-                forward_batch_output.next_token_ids,
-                forward_batch_output.can_run_cuda_graph,
-            )
-
-            # Update the future token ids map
-            bs = len(model_worker_batch.seq_lens)
-            if model_worker_batch.is_prefill_only:
-                # For prefill-only requests, create dummy token IDs on CPU
-                next_token_ids = torch.zeros(bs, dtype=torch.long)
-
-            # store the future indices into future map
-            self.future_map.store_to_map(future_map_ct, bs, next_token_ids)
-
-            # Copy results to the CPU
-            if model_worker_batch.return_logprob:
-                if logits_output.next_token_logprobs is not None:
-                    logits_output.next_token_logprobs = (
-                        logits_output.next_token_logprobs.to("cpu", non_blocking=True)
-                    )
-                if logits_output.input_token_logprobs is not None:
-                    logits_output.input_token_logprobs = (
-                        logits_output.input_token_logprobs.to("cpu", non_blocking=True)
-                    )
-            if logits_output.hidden_states is not None:
-                logits_output.hidden_states = logits_output.hidden_states.to(
-                    "cpu", non_blocking=True
-                )
-            # Only copy to CPU if not already on CPU
-            if next_token_ids.device.type != "cpu":
-                next_token_ids = next_token_ids.to("cpu", non_blocking=True)
-            copy_done.record()
-
-            self.output_queue.put(
-                (copy_done, logits_output, next_token_ids, can_run_cuda_graph)
-            )
-
-    def resolve_last_batch_result(self, launch_done: Optional[threading.Event] = None):
-        """
-        This function is called to resolve the last batch result and
-        wait for the current batch to be launched. Used in overlap mode.
-        """
-        copy_done, logits_output, next_token_ids, can_run_cuda_graph = (
-            self.output_queue.get()
-        )
-
-        if launch_done is not None:
-            launch_done.wait()
-        copy_done.synchronize()
-
-        if logits_output.next_token_logprobs is not None:
-            logits_output.next_token_logprobs = (
-                logits_output.next_token_logprobs.tolist()
-            )
-        if logits_output.input_token_logprobs is not None:
-            logits_output.input_token_logprobs = tuple(
-                logits_output.input_token_logprobs.tolist()
-            )
-        next_token_ids = next_token_ids.tolist()
-        return logits_output, next_token_ids, can_run_cuda_graph
-
-    def forward_batch_generation(
-        self, model_worker_batch: ModelWorkerBatch
-    ) -> ForwardBatchOutput:
-        # Create a new copy of sampling_info because it will be updated in-place by the scheduler for the next batch.
-        sampling_info = model_worker_batch.sampling_info
-        sampling_info.update_penalties()
-        model_worker_batch.sampling_info = self.cur_sampling_info = dataclasses.replace(
-            sampling_info,
-            sampling_info_done=threading.Event(),
-            penalizer_orchestrator=None,
-        )
-
-        # A cuda stream sync here to avoid the cuda illegal memory access error.
-        sync_event = torch.get_device_module(self.device).Event()
-        sync_event.record(self.scheduler_stream)
-
-        # Push a new batch to the queue
-        bs = len(model_worker_batch.seq_lens)
-        cur_future_map_ct = self.future_map.update_ct(bs)
-        self.input_queue.put((model_worker_batch, cur_future_map_ct, sync_event))
-
-        # get this forward batch's future token ids
-        future_next_token_ids = self.future_map.update_next_future(
-            cur_future_map_ct, bs
-        )
-        return ForwardBatchOutput(
-            next_token_ids=future_next_token_ids,
-            can_run_cuda_graph=False,
-        )
-
-    def update_weights_from_disk(self, recv_req: UpdateWeightFromDiskReqInput):
-        success, message = self.worker.update_weights_from_disk(recv_req)
-        return success, message
-
-    def init_weights_update_group(self, recv_req: InitWeightsUpdateGroupReqInput):
-        success, message = self.worker.init_weights_update_group(recv_req)
-        return success, message
-
-    def destroy_weights_update_group(self, recv_req: DestroyWeightsUpdateGroupReqInput):
-        success, message = self.worker.destroy_weights_update_group(recv_req)
-        return success, message
-
-    def init_weights_send_group_for_remote_instance(
-        self, recv_req: InitWeightsSendGroupForRemoteInstanceReqInput
-    ):
-        success, message = self.worker.init_weights_send_group_for_remote_instance(
-            recv_req
-        )
-        return success, message
-
-    def send_weights_to_remote_instance(
-        self, recv_req: SendWeightsToRemoteInstanceReqInput
-    ):
-        success, message = self.worker.send_weights_to_remote_instance(recv_req)
-        return success, message
-
-    def update_weights_from_distributed(
-        self, recv_req: UpdateWeightsFromDistributedReqInput
-    ):
-        success, message = self.worker.update_weights_from_distributed(recv_req)
-        return success, message
-
-    def update_weights_from_tensor(self, recv_req: UpdateWeightsFromTensorReqInput):
-        success, message = self.worker.update_weights_from_tensor(recv_req)
-        return success, message
-
-    def get_weights_by_name(self, recv_req: GetWeightsByNameReqInput):
-        return self.worker.get_weights_by_name(recv_req)
-
-    def load_lora_adapter(self, recv_req: LoadLoRAAdapterReqInput):
-        return self.worker.load_lora_adapter(recv_req)
-
-    def unload_lora_adapter(self, recv_req: UnloadLoRAAdapterReqInput):
-        return self.worker.unload_lora_adapter(recv_req)
-
-    def can_run_lora_batch(self, lora_ids: list[str]) -> bool:
-        return self.worker.can_run_lora_batch(lora_ids)
-
-    def __delete__(self):
-        self.input_queue.put((None, None))
-        self.copy_queue.put((None, None, None))

sglang/srt/models/vila.py

@@ -1,306 +0,0 @@
-import logging
-from typing import Any, Dict, Iterable, List, Optional, Tuple, cast
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch import Tensor
-from transformers.configuration_utils import PretrainedConfig
-from transformers.modeling_outputs import BaseModelOutputWithPooling
-from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
-from transformers.models.siglip import SiglipVisionConfig, SiglipVisionModel
-
-import sglang.srt.managers.mm_utils as mm_utils
-import sglang.srt.model_loader.weight_utils as weight_utils
-import sglang.srt.utils as utils
-from sglang.srt.layers.logits_processor import LogitsProcessor, LogitsProcessorOutput
-from sglang.srt.layers.pooler import Pooler, PoolingType
-from sglang.srt.layers.quantization.base_config import QuantizationConfig
-from sglang.srt.managers.mm_utils import MultiModalityDataPaddingPatternMultimodalTokens
-from sglang.srt.managers.schedule_batch import (
-    Modality,
-    MultimodalDataItem,
-    MultimodalInputs,
-)
-from sglang.srt.model_executor.forward_batch_info import ForwardBatch
-from sglang.srt.models.qwen2 import Qwen2ForCausalLM
-
-logger = logging.getLogger(__name__)
-
-
-##### BEGIN COPY configuration.py #####
-
-
-class VILAConfig(PretrainedConfig):
-    # Class attributes.
-    model_type: str = "vila"
-    sub_configs: Dict[str, PretrainedConfig] = {
-        "text_config": Qwen2Config(),
-        "vision_config": SiglipVisionConfig(),
-    }
-    _auto_class: Optional[str] = "AutoConfig"
-
-    # Configuration for sub-modules.
-    text_config: Qwen2Config = Qwen2Config()
-    vision_config: SiglipVisionConfig = SiglipVisionConfig()
-
-    # Model configuration.
-    hidden_size: int
-    image_token_id: int
-    mm_hidden_size: int
-    mm_projector_type: str
-    mm_vision_select_feature: str
-    mm_vision_select_layer: int
-    video_token_id: int
-
-    def __init__(
-        self,
-        text_config: Optional[Dict[str, Any]] = None,
-        vision_config: Optional[Dict[str, Any]] = None,
-        *,
-        hidden_size: int = 1536,
-        image_token_id: int = 151649,
-        mm_hidden_size: int = 1152,
-        mm_projector_type: str = "mlp_downsample_3x3_fix",
-        mm_vision_select_feature: str = "cls_patch",
-        mm_vision_select_layer: int = -2,
-        video_token_id: int = 151650,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-
-        self.text_config = Qwen2Config(**text_config) if text_config else Qwen2Config()
-        self.vision_config = (
-            SiglipVisionConfig(**vision_config)
-            if vision_config
-            else SiglipVisionConfig()
-        )
-
-        self.hidden_size = hidden_size
-        self.image_token_id = image_token_id
-        self.mm_hidden_size = mm_hidden_size
-        self.mm_projector_type = mm_projector_type
-        self.mm_vision_select_feature = mm_vision_select_feature
-        self.mm_vision_select_layer = mm_vision_select_layer
-        self.video_token_id = video_token_id
-
-
-##### END COPY configuration.py #####
-
-##### BEGIN COPY modeling_vila.py #####
-
-
-class DownSample3x3BlockFix(nn.Module):
-    def forward(self, x: Tensor) -> Tensor:
-        """
-        Args:
-            x: The input tensor of shape (batch_size, sequence_length, mm_hidden_size).
-
-        Returns:
-            The output tensor of shape (batch_size, image_pad_len, mm_hidden_size * 9).
-        """
-
-        batch_size, sequence_length, hidden_size = x.shape
-
-        feat_size = int(sequence_length**0.5)
-        if feat_size**2 != sequence_length:
-            raise ValueError(
-                f"Cannot take square root: sequence_length {sequence_length} is not a perfect square"
-            )
-
-        features = x.reshape(batch_size, feat_size, feat_size, hidden_size)
-
-        pad_after = (3 - feat_size % 3) % 3
-        if pad_after > 0:
-            features = F.pad(features, (0, 0, 0, pad_after, 0, pad_after))
-            feat_size = feat_size + pad_after
-
-        features = features.reshape(
-            batch_size, feat_size // 3, 3, feat_size // 3, 3, hidden_size
-        )
-        features = features.permute(0, 1, 3, 2, 4, 5).contiguous()
-        features = features.reshape(batch_size, -1, 9 * hidden_size)
-
-        return features
-
-
-class MultimodalProjector(nn.Module):
-    layers: nn.Sequential
-
-    def __init__(
-        self,
-        config: VILAConfig,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-
-        if config.mm_projector_type == "mlp_downsample_3x3_fix":
-            self.layers = nn.Sequential(
-                DownSample3x3BlockFix(),
-                nn.LayerNorm(config.mm_hidden_size * 9),
-                nn.Linear(
-                    config.mm_hidden_size * 9,
-                    config.mm_hidden_size * 3,
-                ),
-                nn.GELU(),
-                nn.LayerNorm(config.vision_config.hidden_size * 3),
-                nn.Linear(config.vision_config.hidden_size * 3, config.hidden_size),
-                nn.GELU(),
-                nn.Linear(config.hidden_size, config.hidden_size),
-            )
-        else:
-            raise NotImplementedError(
-                f"Unsupported mm_projector_type: {config.mm_projector_type}"
-            )
-
-        self.layers.type(config.torch_dtype)
-
-    @property
-    def device(self) -> torch.device:
-        return next(self.parameters()).device
-
-    @property
-    def dtype(self) -> torch.dtype:
-        return next(self.parameters()).dtype
-
-    def forward(self, x: Tensor) -> Tensor:
-        """
-        Args:
-            x: The input tensor of shape (batch_size, sequence_length, mm_hidden_size).
-
-        Returns:
-            The output tensor of shape (batch_size, image_pad_len, hidden_size).
-        """
-
-        return self.layers(x.to(device=self.device, dtype=self.dtype))
-
-
-##### END COPY modeling_vila.py #####
-
-
-class VILAForConditionalGeneration(nn.Module):
-    config: VILAConfig
-    quant_config: Optional[QuantizationConfig]
-
-    logits_processor: LogitsProcessor
-    pooler: Pooler
-
-    llm: Qwen2ForCausalLM
-    mm_projector: MultimodalProjector
-    vision_tower: SiglipVisionModel
-
-    def __init__(
-        self,
-        config: VILAConfig,
-        quant_config: Optional[QuantizationConfig] = None,
-        prefix: str = "",
-    ) -> None:
-        super().__init__()
-
-        self.config = config
-        self.quant_config = quant_config
-
-        self.logits_processor = LogitsProcessor(config)
-        self.pooler = Pooler(pooling_type=PoolingType.LAST, normalize=True)
-
-        self.llm = Qwen2ForCausalLM(
-            config=config.text_config,
-            quant_config=quant_config,
-            prefix=utils.add_prefix("llm", prefix),
-        )
-        self.mm_projector = MultimodalProjector(config)
-        self.vision_tower = SiglipVisionModel(config.vision_config)
-
-    @property
-    def dtype(self) -> torch.dtype:
-        return self.config.torch_dtype
-
-    def forward(
-        self,
-        input_ids: Tensor,
-        positions: Tensor,
-        forward_batch: ForwardBatch,
-        get_embedding: bool = False,
-    ) -> LogitsProcessorOutput:
-        output = mm_utils.general_mm_embed_routine(
-            input_ids=input_ids,
-            forward_batch=forward_batch,
-            language_model=self.llm,
-            data_embedding_funcs={
-                Modality.IMAGE: self.get_image_feature,
-            },
-            get_embedding=get_embedding,
-            positions=positions,
-        )
-
-        return cast(LogitsProcessorOutput, output)
-
-    def get_image_feature(self, mm_input: List[MultimodalDataItem]) -> Tensor:
-        pixel_values = cast(Tensor, mm_input[0].feature)
-
-        ##### BEGIN COPY modeling_vila.py #####
-
-        vision_tower_output: BaseModelOutputWithPooling = self.vision_tower.__call__(
-            pixel_values.to(
-                device=self.vision_tower.device, dtype=self.vision_tower.dtype
-            ),
-            output_hidden_states=True,
-        )
-
-        mm_projector_input = self._vision_tower_output_to_mm_projector_input(
-            vision_tower_output
-        )
-
-        image_embedding: Tensor = self.mm_projector.__call__(
-            mm_projector_input.to(
-                device=self.mm_projector.device, dtype=self.mm_projector.dtype
-            )
-        )
-
-        ##### END COPY modeling_vila.py #####
-
-        return image_embedding
-
-    def load_weights(self, weights: Iterable[Tuple[str, Tensor]]) -> None:
-        params_dict = dict(self.named_parameters())
-
-        for name, loaded_weight in weights:
-            if name.startswith("llm."):
-                self.llm.load_weights([(name[len("llm.") :], loaded_weight)])
-            else:
-                param = params_dict[name]
-                weight_loader = getattr(
-                    param, "weight_loader", weight_utils.default_weight_loader
-                )
-                weight_loader(param, loaded_weight)
-
-    def pad_input_ids(
-        self, input_ids: List[int], mm_inputs: MultimodalInputs
-    ) -> List[int]:
-        pattern = MultiModalityDataPaddingPatternMultimodalTokens()
-        return pattern.pad_input_tokens(input_ids, mm_inputs)
-
-    ##### BEGIN COPY modeling_vila.py #####
-
-    def _vision_tower_output_to_mm_projector_input(
-        self,
-        vision_tower_output: BaseModelOutputWithPooling,
-    ) -> Tensor:
-        assert vision_tower_output.hidden_states is not None
-
-        selected_layer_hidden_states = vision_tower_output.hidden_states[
-            self.config.mm_vision_select_layer
-        ]
-
-        if self.config.mm_vision_select_feature == "cls_patch":
-            return selected_layer_hidden_states
-        else:
-            raise NotImplementedError(
-                f"Unsupported mm_vision_select_feature: {self.config.mm_vision_select_feature}"
-            )
-
-    ##### END COPY modeling_vila.py #####
-
-
-EntryClass = [VILAForConditionalGeneration]