Upload files with `vila-upload`.

Upload tokenizer_config.json
Upload config.json
Upload configuration_vila.py
Upload generation_config.json
Upload special_tokens_map.json
Upload merges.txt
Upload model.safetensors
Upload added_tokens.json
Upload processing_vila.py
Upload vocab.json
Upload processor_config.json
Upload modeling_vila.py
Upload chat_template.json
Upload preprocessor_config.json

added_tokens.json

@@ -0,0 +1,9 @@
+{
+  "<image>": 151648,
+  "<video>": 151649,
+  "<|endoftext|>": 151643,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "[BOS]": 151646,
+  "[PAD]": 151647
+}

chat_template.json

@@ -0,0 +1,3 @@
+{
+  "chat_template": "{% for message in messages %}{% if loop.first and message['role'] != 'system' %}{{ '<|im_start|>system\\nYou are a helpful assistant<|im_end|>\\n' }}{% endif %}{{ '<|im_start|>' + message['role'] + '\\n' }}{% if message['content'] is string %}{{ message['content'] + '<|im_end|>\\n' }}{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' or 'image' in content or 'image_url' in content %}{{ '<image>' }}{% elif content['type'] == 'video' or 'video' in content %}{{ '<video>' }}{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}{{ '<|im_end|>\\n' }}{% endif %}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\\n' }}{% endif %}\n"
+}

config.json

@@ -0,0 +1,74 @@
+{
+  "architectures": [
+    "VILAForConditionalGeneration"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_vila.VILAConfig",
+    "AutoModel": "modeling_vila.VILAForConditionalGeneration",
+    "AutoModelForCausalLM": "modeling_vila.VILAForConditionalGeneration",
+    "AutoModelForImageTextToText": "modeling_vila.VILAForConditionalGeneration",
+    "AutoModelForVision2Seq": "modeling_vila.VILAForConditionalGeneration"
+  },
+  "hidden_size": 1536,
+  "image_end_token_id": 198,
+  "image_token_id": 151648,
+  "mm_hidden_size": 1152,
+  "mm_projector_type": "mlp_downsample_3x3_fix",
+  "mm_vision_select_feature": "cls_patch",
+  "mm_vision_select_layer": -2,
+  "model_type": "vila",
+  "text_config": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "attention_dropout": 0.0,
+    "bos_token_id": 151643,
+    "eos_token_id": 151645,
+    "hidden_act": "silu",
+    "hidden_size": 1536,
+    "initializer_range": 0.02,
+    "intermediate_size": 8960,
+    "max_position_embeddings": 32768,
+    "max_window_layers": 28,
+    "model_max_length": 4096,
+    "model_type": "qwen2",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 28,
+    "num_key_value_heads": 2,
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": null,
+    "rope_theta": 1000000.0,
+    "sliding_window": null,
+    "tie_word_embeddings": true,
+    "tokenizer_model_max_length": 4096,
+    "tokenizer_padding_side": "right",
+    "torch_dtype": "bfloat16",
+    "use_cache": true,
+    "use_sliding_window": false,
+    "vocab_size": 151648
+  },
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.51.3",
+  "video_token_id": 151649,
+  "vision_config": {
+    "architectures": [
+      "SiglipVisionModel"
+    ],
+    "attention_dropout": 0.0,
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "image_size": 448,
+    "intermediate_size": 4304,
+    "layer_norm_eps": 1e-06,
+    "model_type": "siglip_vision_model",
+    "num_attention_heads": 16,
+    "num_channels": 3,
+    "num_hidden_layers": 27,
+    "num_image_tokens": 256,
+    "patch_size": 14,
+    "projection_dim": 2048,
+    "projector_hidden_act": "gelu_fast",
+    "torch_dtype": "bfloat16",
+    "vision_use_head": false
+  }
+}

configuration_vila.py

@@ -0,0 +1,61 @@
+from typing import Any, Dict, Optional
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+from transformers.models.siglip.configuration_siglip import SiglipVisionConfig
+
+
+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
+    image_end_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: Optional[int] = None,
+        image_token_id: Optional[int] = None,
+        image_end_token_id: Optional[int] = None,
+        mm_hidden_size: Optional[int] = None,
+        mm_projector_type: Optional[str] = None,
+        mm_vision_select_feature: Optional[str] = None,
+        mm_vision_select_layer: Optional[int] = None,
+        video_token_id: Optional[int] = None,
+        **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()
+
+        # By default, we use settings from NVILA-Lite.
+        self.hidden_size = hidden_size if hidden_size is not None else 1536
+        self.image_token_id = image_token_id if image_token_id is not None else 151649
+        self.image_end_token_id = image_end_token_id if image_end_token_id is not None else 198  # "\n"
+        self.mm_hidden_size = mm_hidden_size if mm_hidden_size is not None else 1152
+        self.mm_projector_type = mm_projector_type if mm_projector_type is not None else "mlp_downsample_3x3_fix"
+        self.mm_vision_select_feature = (
+            mm_vision_select_feature if mm_vision_select_feature is not None else "cls_patch"
+        )
+        self.mm_vision_select_layer = mm_vision_select_layer if mm_vision_select_layer is not None else -2
+        self.video_token_id = video_token_id if video_token_id is not None else 151650

generation_config.json

@@ -0,0 +1,7 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 151643,
+  "eos_token_id": 151645,
+  "pad_token_id": 151643,
+  "transformers_version": "4.51.3"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d6d04890b3c56e2c052a6dd9b769b0a2b686769c3fbcc8250e9b4494b5575e7
+size 4000366736

modeling_vila.py

@@ -0,0 +1,290 @@
+from typing import List, Optional, Type
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from transformers.configuration_utils import PretrainedConfig
+from transformers.generation.utils import GenerationMixin
+from transformers.modeling_outputs import BaseModelOutputWithPooling, CausalLMOutputWithPast
+from transformers.modeling_utils import PreTrainedModel
+from transformers.models.qwen2.modeling_qwen2 import Qwen2ForCausalLM
+from transformers.models.siglip.modeling_siglip import SiglipVisionModel
+
+from .configuration_vila import VILAConfig
+
+
+class DownSampleBlock(nn.Module):
+    @staticmethod
+    def flat_square(x: Tensor) -> Tensor:
+        n, w, h, c = x.size()
+        if w % 2 == 1:
+            x = torch.concat([x, torch.zeros((n, 1, h, c), device=x.device, dtype=x.dtype)], dim=1).contiguous()
+            n, w, h, c = x.size()
+        if h % 2 == 1:
+            x = torch.concat([x, torch.zeros((n, w, 1, c), device=x.device, dtype=x.dtype)], dim=2).contiguous()
+            n, w, h, c = x.size()
+        x = x.contiguous()
+        x = x.view(n, w, int(h / 2), int(c * 2))
+        x = x.permute(0, 2, 1, 3).contiguous()
+        x = x.view(n, int(h / 2), int(w / 2), int(c * 4))
+        x = x.permute(0, 2, 1, 3).contiguous()
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        vit_embeds = x
+        h = w = int(vit_embeds.shape[1] ** 0.5)
+        vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], h, w, -1)
+        vit_embeds = self.flat_square(vit_embeds)
+        vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], -1, vit_embeds.shape[-1])
+        return vit_embeds
+
+
+class DownSample3x3BlockFix(nn.Module):
+    @staticmethod
+    def flat_square_3x3(x: Tensor) -> Tensor:
+        n, w, h, c = x.size()
+        if w % 3 != 0:
+            x = torch.concat(
+                [
+                    x,
+                    torch.zeros((n, 3 - (w % 3), h, c), device=x.device, dtype=x.dtype),
+                ],
+                dim=1,
+            ).contiguous()
+            n, w, h, c = x.size()
+        x = x.contiguous()
+        if h % 3 != 0:
+            x = torch.concat(
+                [
+                    x,
+                    torch.zeros((n, w, 3 - (h % 3), c), device=x.device, dtype=x.dtype),
+                ],
+                dim=2,
+            ).contiguous()
+            n, w, h, c = x.size()
+        x = x.view(n, w, int(h / 3), int(c * 3))
+        x = x.permute(0, 2, 1, 3).contiguous()
+        x = x.view(n, int(h / 3), int(w / 3), int(c * 9))
+        x = x.permute(0, 2, 1, 3).contiguous()
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        vit_embeds = x
+        h = w = int(vit_embeds.shape[1] ** 0.5)
+        vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], h, w, -1)
+        vit_embeds = self.flat_square_3x3(vit_embeds)
+        vit_embeds = vit_embeds.reshape(vit_embeds.shape[0], -1, vit_embeds.shape[-1])
+        return vit_embeds
+
+
+class MultimodalProjector(nn.Module):
+    layers: nn.Sequential
+
+    def __init__(
+        self,
+        config: VILAConfig,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+
+        match config.mm_projector_type:
+            case "linear":
+                self.layers = nn.Sequential(
+                    nn.Linear(config.vision_config.hidden_size, config.hidden_size),
+                )
+            case "mlp_downsample":
+                self.layers = nn.Sequential(
+                    DownSampleBlock(),
+                    nn.LayerNorm(config.mm_hidden_size * 4),
+                    nn.Linear(config.mm_hidden_size * 4, config.hidden_size),
+                    nn.GELU(),
+                    nn.Linear(config.hidden_size, config.hidden_size),
+                )
+            case "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),
+                )
+            case _:
+                raise NotImplementedError(f"mm_projector_type={config.mm_projector_type} not implemented.")
+
+        self.layers.to(dtype=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:
+        return self.layers(x)
+
+
+class VILAForConditionalGeneration(PreTrainedModel, GenerationMixin):
+    config_class: Type[PretrainedConfig] = VILAConfig
+    base_model_prefix: str = "llm"
+    _auto_class = "AutoModelForImageTextToText"
+    _no_split_modules: List[str] = ["MultimodalProjector"]
+    _skip_keys_device_placement: List[str] = ["past_key_values"]
+    supports_gradient_checkpointing = True
+    _supports_flash_attn_2: bool = True
+    _supports_sdpa = True
+
+    config: VILAConfig
+
+    llm: Qwen2ForCausalLM
+    mm_projector: MultimodalProjector
+    vision_tower: SiglipVisionModel
+
+    def __init__(
+        self,
+        config: VILAConfig,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(config, *args, **kwargs)
+
+        self.llm = Qwen2ForCausalLM(config.text_config, *args, **kwargs)
+        self.mm_projector = MultimodalProjector(config)
+        self.vision_tower = SiglipVisionModel(config.vision_config, *args, **kwargs)
+
+        self.post_init()
+
+    def forward(
+        self,
+        *,
+        attention_mask: Optional[Tensor] = None,
+        input_ids: Optional[Tensor] = None,
+        inputs_embeds: Optional[Tensor] = None,
+        pixel_values: Optional[Tensor] = None,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        # Vision info is only used for prefilling.
+        if kwargs.get("past_key_values", None) is not None:
+            pixel_values = None
+
+        inputs_embeds = inputs_embeds.to(dtype=self.dtype) if inputs_embeds is not None else None
+        pixel_values = pixel_values.to(dtype=self.dtype) if pixel_values is not None else None
+
+        if inputs_embeds is None:
+            assert input_ids is not None
+
+            inputs_embeds = self._embed(input_ids, pixel_values)
+        else:
+            assert input_ids is None
+            assert pixel_values is None
+
+        outputs = self.llm.__call__(
+            inputs_embeds=inputs_embeds.to(
+                device=self.llm.device,
+                dtype=self.llm.dtype,
+            ),
+            attention_mask=(
+                attention_mask.to(
+                    device=self.llm.device,
+                )
+                if attention_mask is not None
+                else None
+            ),
+            **kwargs,
+        )
+
+        return outputs
+
+    def get_output_embeddings(self) -> nn.Module:
+        return self.llm.get_output_embeddings()
+
+    def _embed(
+        self,
+        input_ids: Tensor,
+        pixel_values: Optional[Tensor],
+    ) -> Tensor:
+        """Gets the embedding of the input ids and pixel values.
+
+        Args:
+            input_ids: The input ids.
+            pixel_values: The pixel values.
+
+        Returns:
+            The embedding of the input ids and pixel values.
+        """
+
+        # Video tokens should be removed during preprocessing, so there must not be any video
+        # tokens in the input ids.
+        if torch.any(input_ids == self.config.video_token_id):
+            raise ValueError("Video token ids should not be present in the input ids.")
+
+        image_token_mask = input_ids == self.config.image_token_id
+
+        text_embedding: Tensor = self.llm.get_input_embeddings().__call__(input_ids * ~image_token_mask)
+
+        if pixel_values is None:
+            return text_embedding
+
+        image_features: BaseModelOutputWithPooling = self.vision_tower.__call__(
+            pixel_values.to(
+                device=self.vision_tower.device,
+                dtype=self.vision_tower.dtype,
+            ),
+            output_hidden_states=True,
+        )
+        assert image_features.hidden_states is not None
+
+        # Select image feature.
+        selected_layer_output = image_features.hidden_states[self.config.mm_vision_select_layer]
+        match self.config.mm_vision_select_feature:
+            case "cls_patch":
+                selected_feature = selected_layer_output
+            case _:
+                raise NotImplementedError(
+                    f"mm_vision_select_feature={self.config.mm_vision_select_feature} not implemented."
+                )
+
+        # TODO: Support dynamic_s2.
+
+        image_embedding: Tensor = self.mm_projector.__call__(
+            selected_feature.to(
+                device=self.mm_projector.device,
+                dtype=self.mm_projector.dtype,
+            )
+        )
+
+        # Append image end token to every image embedding.
+        image_end_token_embedding: Tensor = self.llm.get_input_embeddings().__call__(
+            torch.tensor(
+                self.config.image_end_token_id,
+                device=next(self.llm.get_input_embeddings().parameters()).device,
+                dtype=torch.long,
+            ).view(1, -1)
+        )  # Shape: (1, 1, dim_feature)
+        image_end_token_embedding = image_end_token_embedding.expand(
+            image_embedding.shape[0], 1, -1
+        )  # Shape: (n_images, 1, dim_feature)
+        image_embedding = torch.concat(
+            [
+                image_embedding,
+                image_end_token_embedding.to(device=image_embedding.device),
+            ],
+            dim=1,
+        )
+
+        n_images, n_feature, dim_feature = image_embedding.shape
+        image_embedding = image_embedding.view(n_images * n_feature, dim_feature)
+
+        text_embedding[image_token_mask.to(device=text_embedding.device)] = image_embedding.to(
+            device=text_embedding.device
+        )
+
+        return text_embedding

preprocessor_config.json

@@ -0,0 +1,27 @@
+{
+  "auto_map": {
+    "AutoProcessor": "processing_vila.VILAProcessor"
+  },
+  "do_convert_rgb": null,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "SiglipImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "processor_class": "VILAProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 448,
+    "width": 448
+  }
+}

processing_vila.py

@@ -0,0 +1,443 @@
+from typing import List, Optional, Tuple, cast
+
+import transformers.image_transforms as image_transforms
+import transformers.image_utils as image_utils
+import transformers.utils.logging
+from PIL.Image import Image
+from torch import Tensor
+from transformers.feature_extraction_utils import BatchFeature
+from transformers.image_processing_utils import BaseImageProcessor
+from transformers.image_processing_utils_fast import BaseImageProcessorFast
+from transformers.image_utils import ImageInput, VideoInput
+from transformers.models.siglip.image_processing_siglip import SiglipImageProcessor
+from transformers.models.siglip.image_processing_siglip_fast import SiglipImageProcessorFast
+from transformers.processing_utils import ImagesKwargs, ProcessingKwargs, ProcessorMixin, Unpack
+from transformers.tokenization_utils import PreTrainedTokenizer
+from transformers.tokenization_utils_base import PreTrainedTokenizerBase, TextInput
+
+logger = transformers.utils.logging.get_logger(__name__)
+
+
+class VILAProcessorProcessingKwargs(ProcessingKwargs, total=False):
+    _defaults = {}  # type: ignore
+
+
+class VILAProcessorOutput(BatchFeature):
+    input_ids: List[List[int]] | Tensor
+    attention_mask: List[List[int]] | Tensor
+    pixel_values: Optional[List[Tensor] | Tensor]
+
+
+class VILAProcessor(ProcessorMixin):
+    attributes: List[str] = [
+        "image_processor",
+        "tokenizer",
+    ]
+    image_processor_class: str = "AutoImageProcessor"
+    tokenizer_class: str = "AutoTokenizer"
+    _auto_class: str = "AutoProcessor"
+    valid_kwargs: List[str] = [
+        "chat_template",
+        "image_pad_len",
+        "max_tiles",
+        "min_tiles",
+    ]
+
+    # Attributes.
+    image_processor: BaseImageProcessor | BaseImageProcessorFast
+    tokenizer: PreTrainedTokenizerBase
+
+    # Configuration parameters.
+    image_pad_len: int
+    max_tiles: int
+    min_tiles: int
+
+    def __init__(
+        self,
+        image_processor: BaseImageProcessor,
+        tokenizer: PreTrainedTokenizer,
+        *,
+        image_pad_len: Optional[int] = None,
+        max_tiles: Optional[int] = None,
+        min_tiles: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            image_processor,
+            tokenizer,
+            **kwargs,
+        )
+
+        self.image_pad_len = image_pad_len if image_pad_len is not None else 122
+        self.max_tiles = max_tiles if max_tiles is not None else 12
+        self.min_tiles = min_tiles if min_tiles is not None else 1
+
+    def __call__(
+        self,
+        text: TextInput | List[TextInput],
+        images: Optional[ImageInput] = None,
+        videos: Optional[VideoInput] = None,
+        audio: None = None,
+        **kwargs: Unpack[VILAProcessorProcessingKwargs],
+    ) -> VILAProcessorOutput:
+        """Preprocesses inputs for VILA.
+
+        Args:
+            text: The text to be processed.
+            images: The images to be processed.
+            videos: The videos to be processed.
+            audio: Not available.
+            **kwargs: Additional arguments for processing.
+
+        Returns:
+            The processed inputs that can be fed to the model.
+        """
+
+        merged_kwargs = self._merge_kwargs(
+            VILAProcessorProcessingKwargs,  # type: ignore
+            tokenizer_init_kwargs=self.tokenizer.init_kwargs,
+            **kwargs,
+        )
+
+        text, images, videos = self._prepare_inputs(
+            text=text,
+            images=images,
+            videos=videos,
+        )
+
+        # Process videos.
+        text, images, video_flags = self._treat_videos_as_image_seqs(
+            text=text,
+            images=images,
+            videos=videos,
+        )
+
+        # Process images.
+        image_inputs, num_cropped_images = self._process_images(
+            images=images,
+            **merged_kwargs["images_kwargs"],
+        )
+
+        # Process text.
+        text = self._pad_image_tokens_by_num_crops(
+            text,
+            num_cropped_images=num_cropped_images,
+            video_flags=video_flags,
+        )
+
+        text = self._pad_image_tokens_by_num_embeddings(text)
+
+        text_inputs = self.tokenizer.__call__(
+            text,
+            **merged_kwargs["text_kwargs"],
+        )
+
+        return VILAProcessorOutput(
+            data={
+                **text_inputs,
+                **image_inputs,
+            }
+        )
+
+    def _crop_image(
+        self,
+        image: Image,
+    ) -> List[Image]:
+        """Crops the image into multiple tiles.
+
+        Args:
+            image: The image to be cropped.
+
+        Returns:
+            The cropped images.
+        """
+
+        # TODO: Support more image processors.
+        if not isinstance(self.image_processor, (SiglipImageProcessor, SiglipImageProcessorFast)):
+            raise NotImplementedError
+
+        assert self.image_processor.size["height"] == self.image_processor.size["width"]
+        cropped_size = self.image_processor.size["height"]
+
+        cropped_images: List[Image] = dynamic_preprocess(
+            image,
+            min_num=self.min_tiles,
+            max_num=self.max_tiles,
+            image_size=cropped_size,
+        )
+
+        return cropped_images
+
+    def _pad_image_tokens_by_num_crops(
+        self,
+        text: List[str],
+        *,
+        num_cropped_images: List[int],
+        video_flags: List[bool],
+    ) -> List[str]:
+        """Pads each \\<image> to num_cropped_images of "\\<image>\\n" for images and "\\<video>" for videos.
+
+        Args:
+            text: The text to be padded.
+            num_cropped_images: The number of cropped images for each image token.
+            video_flags: A list of flags indicating whether the num_cropped_images item is a video.
+
+        Returns:
+            The padded text.
+        """
+
+        assert len(num_cropped_images) == len(
+            video_flags
+        ), "num_cropped_images and video_flags must have the same length."
+
+        image_token: str = cast(str, self.tokenizer.image_token)
+
+        return_text: List[str] = []
+
+        for text_item in text:
+            return_text_item: str = ""
+
+            # Repeatedly find image_token in the text.
+            while image_token in text_item:
+                image_pos = text_item.find(image_token)
+
+                if image_pos != -1 and len(num_cropped_images) > 0:
+                    num_crops = num_cropped_images.pop(0)
+                    video_flag = video_flags.pop(0)
+
+                    return_text_item += (
+                        text_item[:image_pos] + (image_token if video_flag else (image_token + "\n")) * num_crops
+                    )
+                    text_item = text_item[image_pos + len(image_token) :]
+
+                else:
+                    break
+
+            # Must place outside the while loop.
+            if image_token in text_item:
+                raise ValueError("Too many image tokens in the text.")
+
+            return_text_item += text_item
+            text_item = ""
+
+            return_text.append(return_text_item)
+
+        if len(num_cropped_images) != 0:
+            raise ValueError("Too many images provided.")
+
+        return return_text
+
+    def _pad_image_tokens_by_num_embeddings(
+        self,
+        text: List[str],
+    ) -> List[str]:
+        """Pads each \\<image> to image_pad_len times of "\\<image>".
+
+        Args:
+            text: The text to be padded.
+
+        Returns:
+            The padded text.
+        """
+
+        return [
+            text_item.replace(
+                cast(str, self.tokenizer.image_token), cast(str, self.tokenizer.image_token) * self.image_pad_len
+            )
+            for text_item in text
+        ]
+
+    @staticmethod
+    def _prepare_inputs(
+        text: TextInput | List[TextInput],
+        images: Optional[ImageInput],
+        videos: Optional[VideoInput],
+    ) -> Tuple[List[str], List[Image], List[List[Image]]]:
+        # Prepare text.
+        text = text if isinstance(text, list) else [text]
+
+        # Prepare images.
+        if images is not None:
+            image_list = cast(List, image_utils.make_flat_list_of_images(images))
+            images = [image_transforms.to_pil_image(image) for image in image_list]
+        else:
+            images = cast(List[Image], [])
+
+        # Prepare videos.
+        if videos is not None:
+            video_list = cast(List[List], image_utils.make_batched_videos(videos))
+            videos = [[image_transforms.to_pil_image(image) for image in video] for video in video_list]
+        else:
+            videos = cast(List[List[Image]], [])
+
+        return text, images, videos
+
+    def _process_images(
+        self,
+        images: List[Image],
+        **kwargs: Unpack[ImagesKwargs],
+    ) -> Tuple[BatchFeature, List[int]]:
+        cropped_images: List[Image] = []
+        num_cropped_images: List[int] = []
+
+        for image in images:
+            single_cropped_images = self._crop_image(image)
+
+            cropped_images.extend(single_cropped_images)
+            num_cropped_images.append(len(single_cropped_images))
+
+        if len(cropped_images) == 0:
+            # The image processor may not properly handle empty image lists.
+            # This is a workaround to avoid errors.
+            return BatchFeature(), num_cropped_images
+
+        image_inputs = self.image_processor.__call__(
+            cropped_images,
+            **kwargs,
+        )
+
+        return image_inputs, num_cropped_images
+
+    def _treat_videos_as_image_seqs(
+        self, text: List[str], images: List[Image], videos: List[List[Image]]
+    ) -> Tuple[List[str], List[Image], List[bool]]:
+        """Treats videos as image sequences.
+
+        This method will replace all video tokens in the text with #frame image tokens,
+        and insert the corresponding images into the images list.
+
+        Args:
+            text: The text to be processed.
+            images: The images to be processed.
+            videos: The videos to be processed.
+
+        Returns:
+            The processed text and images, and a list of flags indicating whether the images are from videos.
+        """
+
+        image_token = cast(str, self.tokenizer.image_token)
+        video_token = cast(str, self.tokenizer.video_token)
+
+        return_text: List[str] = []
+        return_images: List[Image] = []
+        return_video_flags: List[bool] = []
+
+        for text_item in text:
+            return_text_item: str = ""
+
+            # Repeatedly find image_token or video_token in the text.
+            while image_token in text_item or video_token in text_item:
+                image_pos = text_item.find(image_token)
+                video_pos = text_item.find(video_token)
+
+                # If not found, set position to the end of the text.
+                if image_pos == -1:
+                    image_pos = len(text_item)
+                if video_pos == -1:
+                    video_pos = len(text_item)
+
+                if image_pos != len(text_item) and len(images) > 0 and image_pos < video_pos:
+                    # Take an image and keep the image token if:
+                    #   - an image token is found, and
+                    #   - there are images left, and
+                    #   - the image token is before the first video token.
+
+                    image = images.pop(0)
+                    return_images.append(image)
+                    return_video_flags.append(False)
+
+                    return_text_item += text_item[: image_pos + len(image_token)]
+                    text_item = text_item[image_pos + len(image_token) :]
+
+                elif video_pos != len(text_item) and len(videos) > 0 and video_pos < image_pos:
+                    # Take a video and replace the video token with #frame image tokens if:
+                    #   - a video token is found, and
+                    #   - there are videos left, and
+                    #   - the video token is before the first image token.
+
+                    video = videos.pop(0)
+                    return_images.extend(video)
+                    return_video_flags.extend([True] * len(video))
+
+                    return_text_item += text_item[:video_pos] + image_token * len(video)
+                    text_item = text_item[video_pos + len(video_token) :]
+                else:
+                    break
+
+            # Must place outside the while loop.
+            if image_token in text_item:
+                raise ValueError("Too many image tokens in the text.")
+            if video_token in text_item:
+                raise ValueError("Too many video tokens in the text.")
+
+            return_text_item += text_item
+            text_item = ""
+
+            return_text.append(return_text_item)
+
+        if len(images) != 0:
+            raise ValueError("Too many images provided.")
+        if len(videos) != 0:
+            raise ValueError("Too many videos provided.")
+
+        return return_text, return_images, return_video_flags
+
+
+def dynamic_preprocess(image: Image, min_num: int, max_num: int, image_size: int, use_thumbnail=True) -> List[Image]:
+    orig_width, orig_height = image.size
+    aspect_ratio = orig_width / orig_height
+
+    # calculate the existing image aspect ratio
+    target_ratios = {
+        (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
+
+
+def find_closest_aspect_ratio(
+    aspect_ratio: float, target_ratios: List[Tuple[int, int]], width: int, height: int, image_size: int
+) -> Tuple[int, int]:
+    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

processor_config.json

@@ -0,0 +1,9 @@
+{
+  "auto_map": {
+    "AutoProcessor": "processing_vila.VILAProcessor"
+  },
+  "image_pad_len": 122,
+  "max_tiles": 12,
+  "min_tiles": 1,
+  "processor_class": "VILAProcessor"
+}

special_tokens_map.json

@@ -0,0 +1,29 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>"
+  ],
+  "bos_token": {
+    "content": "[BOS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "image_token": "<image>",
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "video_token": "<video>"
+}

tokenizer_config.json

@@ -0,0 +1,87 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "[BOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<video>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>"
+  ],
+  "auto_map": {
+    "AutoProcessor": "processing_vila.VILAProcessor"
+  },
+  "bos_token": "[BOS]",
+  "chat_template": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {
+    "image_token": "<image>",
+    "video_token": "<video>"
+  },
+  "image_token": "<image>",
+  "legacy": false,
+  "model_max_length": 4096,
+  "pad_token": "<|endoftext|>",
+  "padding_side": "left",
+  "processor_class": "VILAProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<video>"
+}