upload Cheers-v1.0

init, upload Cheers-v1.0

config.json

@@ -0,0 +1,44 @@
+{
+    "architectures": [
+        "Cheers"
+    ],
+        "auto_map": {
+        "AutoConfig": "configuration_umm.UMMConfig",
+        "AutoModel": "modeling_umm.UMMModel",
+        "AutoModelForCausalLM": "modeling_umm.Cheers"
+    },
+    "vae_encoder_config": {
+        "resolution": 512
+    },
+    "vae_decoder_config": {
+        "resolution": 512
+    },
+    "vision_representation_config": {
+        "attention_dropout": 0.0,
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 1152,
+        "image_size": 512,
+        "intermediate_size": 4304,
+        "layer_norm_eps": 1e-06,
+        "model_type": "umm",
+        "num_attention_heads": 16,
+        "num_channels": 3,
+        "num_hidden_layers": 27,
+        "num_patches": 1024,
+        "patch_size": 16
+    },
+    "text_config":{
+        "hidden_size": 1536,
+        "intermediate_size": 8960,
+        "max_window_layers": 21,
+        "num_attention_heads": 12,
+        "num_key_value_heads": 2,
+        "sliding_window": 32768,
+        "tie_word_embeddings": true,
+        "vocab_size": 151936,
+        "max_position_embeddings": 32768
+    },
+    "model_type": "umm",
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.51.3"
+}

configuration_umm.py

@@ -0,0 +1,191 @@
+from transformers.configuration_utils import PretrainedConfig
+from transformers.modeling_rope_utils import rope_config_validation
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+class VAEEncoderConfig(PretrainedConfig):
+    model_type = "umm"
+    base_config_key = "vae_encoder_config"
+
+    def __init__(
+        self,
+        resolution=256,
+        in_channels=3,
+        ch=128,
+        ch_mult=[1,2,4,4],
+        num_res_blocks=2,
+        z_channels=32,
+        **kwargs
+    ):
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.ch = ch
+        self.ch_mult = ch_mult
+        self.num_res_blocks = num_res_blocks
+        self.z_channels = z_channels
+        super().__init__(**kwargs)
+
+class VAEDecoderConfig(PretrainedConfig):
+    model_type = "umm"
+    base_config_key = "vae_decoder_config"
+
+    def __init__(
+        self,
+        ch=128,
+        out_ch=3,
+        ch_mult=[1,2,4,4],
+        num_res_blocks=2,
+        in_channels=3,
+        resolution=256,
+        z_channels=32,
+        **kwargs
+    ):
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.ch = ch
+        self.out_ch = out_ch
+        self.ch_mult = ch_mult
+        self.num_res_blocks = num_res_blocks
+        self.z_channels = z_channels
+        super().__init__(**kwargs)
+
+class Siglip2VisionConfig(PretrainedConfig):
+    model_type = "umm"
+    base_config_key = "vision_representation_config"
+
+    def __init__(
+        self,
+        hidden_size=768,
+        intermediate_size=3072,
+        num_hidden_layers=12,
+        num_attention_heads=12,
+        num_channels=3,
+        image_size=256,
+        patch_size=16,
+        hidden_act="gelu_pytorch_tanh",
+        layer_norm_eps=1e-6,
+        attention_dropout=0.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_channels = num_channels
+        self.patch_size = patch_size
+        self.attention_dropout = attention_dropout
+        self.layer_norm_eps = layer_norm_eps
+        self.hidden_act = hidden_act
+        self.image_size = image_size
+
+class Qwen2Config(PretrainedConfig):
+    model_type = "umm"
+    base_config_key = "text_config"
+
+    def __init__(
+        self,
+        vocab_size=152064,
+        hidden_size=3584,
+        intermediate_size=18944,
+        num_hidden_layers=28,
+        num_attention_heads=28,
+        num_key_value_heads=4,
+        hidden_act="silu",
+        max_position_embeddings=131072,
+        initializer_range=0.02,
+        rms_norm_eps=1e-6,
+        use_cache=True,
+        tie_word_embeddings=False,
+        rope_theta=1000000.0,
+        rope_scaling=None,
+        use_sliding_window=False,
+        sliding_window=131072,
+        max_window_layers=28,
+        layer_types=None,
+        attention_dropout=0.0,
+        **kwargs,
+    ):
+        self.vocab_size = vocab_size
+        self.max_position_embeddings = max_position_embeddings
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.use_sliding_window = use_sliding_window
+        self.sliding_window = sliding_window if self.use_sliding_window else None
+        self.max_window_layers = max_window_layers
+        # for backward compatibility
+        if num_key_value_heads is None:
+            num_key_value_heads = num_attention_heads
+
+        self.num_key_value_heads = num_key_value_heads
+        self.hidden_act = hidden_act
+        self.initializer_range = initializer_range
+        self.rms_norm_eps = rms_norm_eps
+        self.use_cache = use_cache
+        self.rope_theta = rope_theta
+        self.rope_scaling = rope_scaling
+        self.attention_dropout = attention_dropout
+        # Validate the correctness of rotary position embeddings parameters
+        # BC: if there is a 'type' field, move it to 'rope_type'.
+        if self.rope_scaling is not None and "type" in self.rope_scaling:
+            self.rope_scaling["rope_type"] = self.rope_scaling["type"]
+        rope_config_validation(self)
+
+        self.layer_types = layer_types
+        if self.layer_types is None:
+            self.layer_types = [
+                "sliding_attention"
+                if self.sliding_window is not None and i >= self.max_window_layers
+                else "full_attention"
+                for i in range(self.num_hidden_layers)
+            ]
+
+        super().__init__(
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+
+class UMMConfig(PretrainedConfig):
+    model_type = "umm"
+    sub_configs = {
+        "vision_representation_config": Siglip2VisionConfig,
+        "vae_encoder_config": VAEEncoderConfig,
+        "vae_decoder_config": VAEDecoderConfig,
+        "text_config": Qwen2Config,
+        }
+    keys_to_ignore_at_inference = ["past_key_values"]
+    def __init__(
+        self,
+        vision_representation_config=None,
+        vae_encoder_config=None,
+        vae_decoder_config=None,
+        text_config=None,
+        **kwargs,
+    ):
+        if isinstance(vision_representation_config, dict):
+            self.vision_representation_config = self.sub_configs["vision_representation_config"](**vision_representation_config)
+        elif vision_representation_config is None:
+            self.vision_representation_config = self.sub_configs["vision_representation_config"]()
+
+        if isinstance(vae_encoder_config, dict):
+            self.vae_encoder_config = self.sub_configs["vae_encoder_config"](**vae_encoder_config)
+        elif vae_encoder_config is None:
+            self.vae_encoder_config = self.sub_configs["vae_encoder_config"]()
+        
+        if isinstance(vae_decoder_config, dict):
+            self.vae_decoder_config = self.sub_configs["vae_decoder_config"](**vae_decoder_config)
+        elif vae_decoder_config is None:
+            self.vae_decoder_config = self.sub_configs["vae_decoder_config"]()
+        
+        if isinstance(text_config, dict):
+            self.text_config = self.sub_configs["text_config"](**text_config)
+        elif text_config is None:
+            self.text_config = self.sub_configs["text_config"]()
+
+        super().__init__(**kwargs)
+
+__all__ = ["UMMConfig"]

generation_config.json

@@ -0,0 +1,14 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151643
+  ],
+  "pad_token_id": 151643,
+  "repetition_penalty": 1.05,
+  "temperature": 0.7,
+  "top_k": 20,
+  "top_p": 0.8,
+  "transformers_version": "4.51.0"
+}

image_processing_umm.py

@@ -0,0 +1,117 @@
+from networkx import to_numpy_array
+import numpy as np
+import torch
+from PIL import Image, ImageOps
+import math
+from functools import partial, reduce
+from transformers.image_transforms import (
+    convert_to_rgb,
+    center_crop,
+    normalize,
+    rescale,
+    resize,
+    to_channel_dimension_format,
+)
+
+from transformers.image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
+from transformers.image_utils import ImageInput, ChannelDimension, PILImageResampling, to_numpy_array
+
+class UMMImageProcessor(BaseImageProcessor):
+    model_input_names = ["pixel_values", "grid_hws"]
+    def __init__(
+        self,
+        image_mean=(0.5, 0.5, 0.5),
+        image_std=(0.5, 0.5, 0.5),
+        size=(256, 256),
+        crop_size = None, 
+        resample=PILImageResampling.BICUBIC, 
+        rescale_factor=1 / 255, 
+        data_format=ChannelDimension.FIRST,
+        scale_resolution=256,
+        patch_size=16, 
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        crop_size = crop_size if crop_size is not None else {"height": 256, "width": 256}
+        crop_size = get_size_dict(crop_size, default_to_square=True, param_name="crop_size")
+        self.image_mean = image_mean
+        self.image_std = image_std
+        self.size = size
+        self.resample = resample
+        self.rescale_factor = rescale_factor
+        self.data_format = data_format
+        self.crop_size = crop_size
+        self.scale_resolution = scale_resolution
+        self.patch_size = patch_size
+
+    def preprocess(self, image, max_resolution=None, return_tensors = 'pt', und=True, **kwargs) -> BatchFeature:
+        if max_resolution is not None:
+            scale_resolution = max_resolution
+        else:
+            scale_resolution = self.scale_resolution
+        if image is not None:
+            pixel_values, grid_hws = [], []
+            if und:
+                image = self._preprocess_und(image, scale_resolution)
+            else:
+                image = self._preprocess_gen(image, scale_resolution)
+            if not torch.is_tensor(image):
+                image = torch.tensor(image)
+            _,H,W = image.shape
+            grid_h = int(H // self.patch_size)
+            grid_w = int(W // self.patch_size)
+            grid_hw = (grid_h, grid_w)
+            pixel_values = torch.stack([image], dim=0)
+            grid_hws = torch.tensor([grid_hw])
+            data = {
+                "pixel_values": pixel_values,
+                "grid_hws": grid_hws
+            }
+        return BatchFeature(data=data, tensor_type=return_tensors)
+    
+    def _preprocess_gen(self, source_image, scale_resolution):
+        w, h = source_image.size
+        scale = scale_resolution / min(h, w)
+        new_h = int(round(h * scale))
+        new_w = int(round(w * scale))
+        source_image = source_image.resize((new_w, new_h), Image.Resampling.BICUBIC)
+        source_image = [source_image]
+        transforms = [
+            convert_to_rgb,
+            to_numpy_array,
+        ]
+        transforms.append(partial(center_crop, size=(scale_resolution, scale_resolution)))
+        transforms.append(partial(rescale, scale=self.rescale_factor, data_format=self.data_format))
+        transforms.append(partial(to_channel_dimension_format, channel_dim=self.data_format, input_channel_dim=self.data_format))
+        image = reduce(lambda x, f: [*map(f, x)], transforms, source_image)
+        return image[0] if len(image) == 1 else image
+
+    def _preprocess_und(self, source_image, scale_resolution):
+        w, h = source_image.size
+        scale = min(scale_resolution / h, scale_resolution / w)
+        new_h = int(round(h * scale))
+        new_w = int(round(w * scale))
+        resized_image = source_image.resize((new_w, new_h), Image.Resampling.BICUBIC)
+
+        pad_w = scale_resolution - new_w
+        pad_h = scale_resolution - new_h
+
+        left = pad_w // 2
+        right = pad_w - left
+        top = pad_h // 2
+        bottom = pad_h - top
+
+        new_image = ImageOps.expand(resized_image, border=(left, top, right, bottom), fill=(0,0,0))
+        # new_image.save("test_path")
+        source_image = [new_image]
+        transforms = [
+            convert_to_rgb,
+            to_numpy_array
+        ]
+        transforms.append(partial(rescale, scale=self.rescale_factor, data_format=self.data_format))
+        transforms.append(partial(to_channel_dimension_format, channel_dim=self.data_format, input_channel_dim=self.data_format))
+        image = reduce(lambda x, f: [*map(f, x)], transforms, source_image)
+        return image[0] if len(image) == 1 else image
+
+__all__ = ["UMMImageProcessor"]
+

model-00001-of-00002.safetensors

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

model-00002-of-00002.safetensors

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

preprocessor_config.json

@@ -0,0 +1,10 @@
+{
+    "image_processor_type": "UMMImageProcessor",
+    "auto_map":{
+        "AutoProcessor": "processing_umm.UMMProcessor",
+        "AutoImageProcessor": "image_processing_umm.UMMImageProcessor"
+    },
+    "processor_class": "UMMProcessor",
+    "scale_resolution": 512,
+    "patch_size": 16
+}

processing_umm.py

@@ -0,0 +1,125 @@
+from PIL import Image
+from scipy import special
+import torch
+import numpy as np
+from math import e
+from param import output
+from transformers.feature_extraction_utils import BatchFeature
+from transformers.processing_utils import ProcessorMixin
+
+class UMMProcessor(ProcessorMixin):
+    attributes = ["image_processor", "tokenizer"]
+    image_processor_class = "AutoImageProcessor"
+    tokenizer_class = ("Qwen2Tokenizer", "Qwen2TokenizerFast")
+
+    def __init__(self, image_processor=None, tokenizer=None, chat_template=None, **kwargs):
+        self.image_token = "<image>" if not hasattr(tokenizer, "image_token") else tokenizer.image_token
+        if getattr(tokenizer, "image_token_id", None):
+            self.image_token_id = tokenizer.image_token_id
+        else:
+            tokenizer.add_tokens(["<image>"], special_tokens=True)
+            self.image_token_id = -200
+        
+        self.image_gen_token = "<image_gen>" if not hasattr(tokenizer, "image_gen_token") else tokenizer.image_gen_token
+        if getattr(tokenizer, "image_gen_token_id", None):
+            self.image_gen_token_id = tokenizer.image_gen_token_id
+        else:
+            tokenizer.add_tokens(["<image_gen>"], special_tokens=True)
+            self.image_gen_token_id = -300
+        
+        self.image_gen_start_token = "<im_start>" if not hasattr(tokenizer, "image_gen_start") else tokenizer.image_gen_start
+        if getattr(tokenizer, "image_gen_start_token_id", None):
+            self.image_gen_start_token_id = tokenizer.image_gen_start_token_id
+        else:
+            tokenizer.add_tokens(["<im_start>"], special_tokens=True)
+            self.image_gen_start_token_id = tokenizer.convert_tokens_to_ids(self.image_gen_start_token)
+
+        self.image_gen_end_token = "<im_end>" if not hasattr(tokenizer, "image_gen_end") else tokenizer.image_gen_end
+        if getattr(tokenizer, "image_gen_end_token_id", None):
+            self.image_gen_end_token_id = tokenizer.image_gen_end_token_id
+        else:
+            tokenizer.add_tokens(["<im_end>"], special_tokens=True)
+            self.image_gen_end_token_id = tokenizer.convert_tokens_to_ids(self.image_gen_end_token)
+        
+        self.no_mean_token = "<no_mean>" if not hasattr(tokenizer, "no_mean") else tokenizer.no_mean
+        if getattr(tokenizer, "no_mean_id", None):
+            self.no_mean_token_id = tokenizer.no_mean_id
+        else:
+            tokenizer.add_tokens(["<no_mean>"], special_tokens=True)
+            self.no_mean_token_id = tokenizer.convert_tokens_to_ids(self.no_mean_token)
+            
+        if chat_template is None and hasattr(tokenizer, "chat_template"):
+            chat_template = tokenizer.chat_template
+        super().__init__(image_processor, tokenizer, chat_template=chat_template)
+    
+    def __call__(self, images=None, text=None, max_resolution=None, add_im_start_id=False, **kwargs):
+        if "padding" not in kwargs:
+            kwargs["padding"] = True
+        if "truncation" not in kwargs:
+            kwargs["truncation"] = True
+        if not isinstance(text, list):
+            text = [text]
+        text = text.copy()
+        return_tensors = kwargs.pop("return_tensors", None)
+        text_inputs = self.tokenizer(text, **kwargs, return_tensors=return_tensors)
+        img_token_id = self.tokenizer.convert_tokens_to_ids(self.image_token)
+        img_gen_token_id = self.tokenizer.convert_tokens_to_ids(self.image_gen_token)
+        if add_im_start_id:
+            B, T = text_inputs["input_ids"].shape
+            new_input_ids = torch.full((B, T+1), self.tokenizer.pad_token_id)
+            new_input_ids[:, :T] = text_inputs["input_ids"]
+            is_valid = (text_inputs["input_ids"] != self.tokenizer.pad_token_id)
+            valid_len = is_valid.sum(dim=1)
+        else:
+            new_input_ids = text_inputs["input_ids"]
+
+        t = []
+        und_gen_mask_list = []
+        for i, ids in enumerate(text_inputs["input_ids"]):
+            for j, token_id in enumerate(ids):
+                if token_id == img_token_id:
+                    new_input_ids[i][j] = self.image_token_id
+                    t.append(torch.tensor([1.0]))
+                    und_gen_mask_list.append(1)
+                elif token_id == img_gen_token_id:
+                    new_input_ids[i][j] = self.image_gen_token_id
+                    t.append(torch.rand(1))
+                    und_gen_mask_list.append(0)
+        
+        image_inputs = {}
+        pixel_values, grid_hws = [], []
+        if images is not None:
+            image_idx = 0
+            for per_images in images if isinstance(images, list) else [images]:
+                if per_images is None:
+                    dummy_image = Image.fromarray(np.random.randint(0, 256, (256, 256, 3), dtype=np.uint8))
+                    image_info = self.image_processor(images=dummy_image)
+                else:
+                    for per_image in per_images if isinstance(per_images, list) else[per_images]:
+                        if und_gen_mask_list[image_idx] == 0:
+                            image_info = self.image_processor(images=per_image, max_resolution=max_resolution, und=False)
+                        else:
+                            image_info = self.image_processor(images=per_image, max_resolution=max_resolution)
+                        image_idx += 1
+                pixel_values.append(image_info.pixel_values)
+                grid_hws.append(image_info.grid_hws)
+            pixel_values = torch.concat(pixel_values, dim=0)
+            grid_hws = torch.concat(grid_hws, dim=0)
+            image_inputs.update({'pixel_values': pixel_values, 'grid_hws': grid_hws})
+
+        if len(t) > 0:
+            t = torch.cat(t)
+            image_inputs.update({"t":t})
+        if add_im_start_id:
+            for b in range(B):
+                pos = valid_len[b].item()
+                new_input_ids[b, pos] = self.image_gen_start_token_id
+            attention_mask = torch.cat([
+                text_inputs["attention_mask"],
+                (new_input_ids[:, -1] != self.tokenizer.pad_token_id).long().unsqueeze(1)
+            ], dim=1)
+            text_inputs["attention_mask"] = attention_mask
+        text_inputs["input_ids"] = new_input_ids
+        return BatchFeature(data={**text_inputs, **image_inputs}, tensor_type=return_tensors)
+
+__all__ = ["UMMProcessor"]

tokenizer_config.json

@@ -0,0 +1,207 @@
+{
+  "add_bos_token": false,
+  "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": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "chat_template": "{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n' }}{% endif %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "model_max_length": 131072,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null
+}