Duplicate from openbmb/MiniCPM-Llama3-V-2_5

Co-authored-by: Hongji Zhu <[email protected]>

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,199 @@
+---
+pipeline_tag: image-text-to-text
+language:
+- multilingual
+datasets:
+- openbmb/RLAIF-V-Dataset
+library_name: transformers
+tags:
+- minicpm-v
+- vision
+- ocr
+- custom_code
+---
+
+
+<h1>A GPT-4V Level Multimodal LLM on Your Phone</h1>
+
+[GitHub](https://github.com/OpenBMB/MiniCPM-V) | [Demo](https://huggingface.co/spaces/openbmb/MiniCPM-Llama3-V-2_5) | <a href="https://github.com/OpenBMB/MiniCPM-V/blob/main/docs/wechat.md" target="_blank"> WeChat</a> 
+
+
+## News <!-- omit in toc -->
+
+#### 📌 Pinned
+
+* [2025.01.14] 🔥🔥 🔥 We open source [**MiniCPM-o 2.6**](https://huggingface.co/openbmb/MiniCPM-o-2_6), with significant performance improvement over **MiniCPM-V 2.6**, and support real-time speech-to-speech conversation and multimodal live streaming. Try it now. 
+
+* [2024.08.10] 🚀🚀🚀 MiniCPM-Llama3-V 2.5 is now fully supported by [official](https://github.com/ggerganov/llama.cpp) llama.cpp! GGUF models of various sizes are available [here](https://huggingface.co/openbmb/MiniCPM-Llama3-V-2_5-gguf).
+* [2024.08.06] 🔥🔥🔥 We open-source [**MiniCPM-V 2.6**](https://huggingface.co/openbmb/MiniCPM-V-2_6), which outperforms GPT-4V on single image, multi-image and video understanding. It advances popular features of MiniCPM-Llama3-V 2.5, and can support real-time video understanding on iPad. Try it now!
+* [2024.08.03] MiniCPM-Llama3-V 2.5 technical report is released! See [here](https://github.com/OpenBMB/MiniCPM-V/tree/main/docs/MiniCPM_Llama3_V_25_technical_report.pdf).
+* [2024.07.19] MiniCPM-Llama3-V 2.5 supports vLLM now! See [here](https://github.com/OpenBMB/MiniCPM-V/tree/main?tab=readme-ov-file#vllm).
+* [2024.05.28] 💫 We now support LoRA fine-tuning for MiniCPM-Llama3-V 2.5, using only 2 V100 GPUs! See more statistics [here](https://github.com/OpenBMB/MiniCPM-V/tree/main/finetune#model-fine-tuning-memory-usage-statistics).
+* [2024.05.23] 🔥🔥🔥 MiniCPM-V tops GitHub Trending and HuggingFace Trending! Our demo, recommended by Hugging Face Gradio’s official account, is available [here](https://huggingface.co/spaces/openbmb/MiniCPM-Llama3-V-2_5). Come and try it out!
+* [2024.05.20] We open-soure MiniCPM-Llama3-V 2.5, it has improved OCR capability and supports 30+ languages, representing the first end-side MLLM achieving GPT-4V level performance! We provide [efficient inference](#deployment-on-mobile-phone) and [simple fine-tuning](https://github.com/OpenBMB/MiniCPM-V/blob/main/finetune/readme.md). Try it now!
+
+
+## Model Summary
+
+**MiniCPM-Llama3-V 2.5** is the latest model in the MiniCPM-V series. The model is built on SigLip-400M and Llama3-8B-Instruct with a total of 8B parameters. It exhibits a significant performance improvement over MiniCPM-V 2.0. Notable features of MiniCPM-Llama3-V 2.5 include:
+
+- 🔥 **Leading Performance.**
+  MiniCPM-Llama3-V 2.5 has achieved an average score of 65.1 on OpenCompass, a comprehensive evaluation over 11 popular benchmarks. **With only 8B parameters, it surpasses widely used proprietary models like GPT-4V-1106, Gemini Pro, Claude 3 and Qwen-VL-Max** and greatly outperforms other Llama 3-based MLLMs.
+
+- 💪 **Strong OCR Capabilities.**
+  MiniCPM-Llama3-V 2.5 can process images with any aspect ratio and up to 1.8 million pixels (e.g., 1344x1344), achieving an **700+ score on OCRBench, surpassing proprietary models such as GPT-4o, GPT-4V-0409, Qwen-VL-Max and Gemini Pro**. Based on recent user feedback, MiniCPM-Llama3-V 2.5 has now enhanced full-text OCR extraction, table-to-markdown conversion, and other high-utility capabilities, and has further strengthened its instruction-following and complex reasoning abilities, enhancing multimodal interaction experiences.
+
+- 🏆 **Trustworthy Behavior.**
+  Leveraging the latest [RLAIF-V](https://github.com/RLHF-V/RLAIF-V/) method (the newest technology in the [RLHF-V](https://github.com/RLHF-V) [CVPR'24] series), MiniCPM-Llama3-V 2.5 exhibits more trustworthy behavior. It achieves **10.3%** hallucination rate on Object HalBench, lower than GPT-4V-1106 (13.6%), achieving the best-level performance within the open-source community. [Data released](https://huggingface.co/datasets/openbmb/RLAIF-V-Dataset).
+
+- 🌏 **Multilingual Support.**
+  Thanks to the strong multilingual capabilities of Llama 3 and the cross-lingual generalization technique from [VisCPM](https://github.com/OpenBMB/VisCPM), MiniCPM-Llama3-V 2.5 extends its bilingual (Chinese-English) multimodal capabilities to **over 30 languages including German, French, Spanish, Italian, Korean, Japanese etc.** [All Supported Languages](./assets/minicpm-llama-v-2-5_languages.md).
+
+- 🚀 **Efficient Deployment.**
+  MiniCPM-Llama3-V 2.5 systematically employs **model quantization, CPU optimizations, NPU optimizations and compilation optimizations**, achieving high-efficiency deployment on edge devices. For mobile phones with Qualcomm chips, we have integrated the NPU acceleration framework QNN into llama.cpp for the first time. After systematic optimization, MiniCPM-Llama3-V 2.5 has realized a **150-fold acceleration in multimodal large model end-side image encoding** and a **3-fold increase in language decoding speed**.
+
+-  💫  **Easy Usage.**
+  MiniCPM-Llama3-V 2.5 can be easily used in various ways: (1) [llama.cpp](https://github.com/OpenBMB/llama.cpp/blob/minicpm-v2.5/examples/minicpmv/README.md) and [ollama](https://github.com/OpenBMB/ollama/tree/minicpm-v2.5/examples/minicpm-v2.5) support for efficient CPU inference on local devices, (2) [GGUF](https://huggingface.co/openbmb/MiniCPM-Llama3-V-2_5-gguf) format quantized models in 16 sizes, (3) efficient [LoRA](https://github.com/OpenBMB/MiniCPM-V/tree/main/finetune#lora-finetuning) fine-tuning with only 2 V100 GPUs, (4) [streaming output](https://huggingface.co/openbmb/MiniCPM-Llama3-V-2_5#usage), (5) quick local WebUI demo setup with [Gradio](https://github.com/OpenBMB/MiniCPM-V/blob/main/web_demo_2.5.py) and [Streamlit](https://github.com/OpenBMB/MiniCPM-V/blob/main/web_demo_streamlit-2_5.py), and (6) interactive demos on [HuggingFace Spaces](https://huggingface.co/spaces/openbmb/MiniCPM-Llama3-V-2_5).
+
+### Evaluation <!-- omit in toc -->
+
+Results on TextVQA, DocVQA, OCRBench, OpenCompass MultiModal Avg , MME, MMBench, MMMU, MathVista, LLaVA Bench, RealWorld QA, Object HalBench.
+
+<div align="center">
+    <img src="https://cdn-uploads.huggingface.co/production/uploads/64abc4aa6cadc7aca585dddf/v2KE3wqQgM05ZW3dH2wbx.png" width="110%" />
+</div>
+
+
+Evaluation results of multilingual LLaVA Bench 
+<div align="center">
+    <img src="assets/minicpmv-llama3-v2.5/llavabench_compare.png" width="110%" />
+</div>
+
+
+### Examples <!-- omit in toc -->
+
+<table align="center">
+    <p align="center">
+      <img src="assets/minicpmv-llama3-v2.5/cases_all.png" width=95%/>
+    </p>
+</table>
+
+We deploy MiniCPM-Llama3-V 2.5 on end devices. The demo video is the raw screen recording on a Xiaomi 14 Pro without edition.
+
+<table align="center">
+    <p align="center">
+      <img src="assets/gif_cases/ticket.gif" width=40% style="display:inline-block;"/>
+      <img src="assets/gif_cases/meal_plan.gif" width=40% style="display:inline-block;"/>
+    </p>
+</table>
+
+<table align="center">
+    <p align="center">
+      <img src="assets/gif_cases/1-4.gif" width=80%/>
+    </p>
+</table>
+
+
+
+## Demo
+Click here to try out the Demo of [MiniCPM-Llama3-V 2.5](https://huggingface.co/spaces/openbmb/MiniCPM-Llama3-V-2_5).
+
+## Deployment on Mobile Phone
+Coming soon.
+
+## Usage
+Inference using Huggingface transformers on NVIDIA GPUs. Requirements tested on python 3.10：
+```
+Pillow==10.1.0
+torch==2.1.2
+torchvision==0.16.2
+transformers==4.40.0
+sentencepiece==0.1.99
+```
+
+```python
+# test.py
+import torch
+from PIL import Image
+from transformers import AutoModel, AutoTokenizer
+
+model = AutoModel.from_pretrained('openbmb/MiniCPM-Llama3-V-2_5', trust_remote_code=True, torch_dtype=torch.float16)
+model = model.to(device='cuda')
+
+tokenizer = AutoTokenizer.from_pretrained('openbmb/MiniCPM-Llama3-V-2_5', trust_remote_code=True)
+model.eval()
+
+image = Image.open('xx.jpg').convert('RGB')
+question = 'What is in the image?'
+msgs = [{'role': 'user', 'content': question}]
+
+res = model.chat(
+    image=image,
+    msgs=msgs,
+    tokenizer=tokenizer,
+    sampling=True, # if sampling=False, beam_search will be used by default
+    temperature=0.7,
+    # system_prompt='' # pass system_prompt if needed
+)
+print(res)
+
+## if you want to use streaming, please make sure sampling=True and stream=True
+## the model.chat will return a generator
+res = model.chat(
+    image=image,
+    msgs=msgs,
+    tokenizer=tokenizer,
+    sampling=True,
+    temperature=0.7,
+    stream=True
+)
+
+generated_text = ""
+for new_text in res:
+    generated_text += new_text
+    print(new_text, flush=True, end='')
+```
+
+Please look at [GitHub](https://github.com/OpenBMB/MiniCPM-V) for more detail about usage.
+
+
+## Inference with llama.cpp<a id="llamacpp"></a>
+MiniCPM-Llama3-V 2.5 can run with llama.cpp now! See our fork of [llama.cpp](https://github.com/OpenBMB/llama.cpp/tree/minicpm-v2.5/examples/minicpmv) for more detail.
+
+
+## Int4 quantized version
+Download the int4 quantized version for lower GPU memory (8GB) usage:  [MiniCPM-Llama3-V-2_5-int4](https://huggingface.co/openbmb/MiniCPM-Llama3-V-2_5-int4).
+
+## MiniCPM-V 2.0 <!-- omit in toc -->
+Please see the info about MiniCPM-V 2.0 [here](https://huggingface.co/openbmb/MiniCPM-V-2).
+
+## License
+#### Model License
+* The code in this repo is released under the [Apache-2.0](https://github.com/OpenBMB/MiniCPM/blob/main/LICENSE) License. 
+* The usage of MiniCPM-V series model weights must strictly follow [MiniCPM Model License.md](https://github.com/OpenBMB/MiniCPM/blob/main/MiniCPM%20Model%20License.md).
+* The models and weights of MiniCPM are completely free for academic research. after filling out a ["questionnaire"](https://modelbest.feishu.cn/share/base/form/shrcnpV5ZT9EJ6xYjh3Kx0J6v8g) for registration, are also available for free commercial use.
+
+
+
+#### Statement
+* As an LLM, MiniCPM-Llama3-V 2.5 generates contents by learning a large mount of texts, but it cannot comprehend, express personal opinions or make value judgement. Anything generated by MiniCPM-Llama3-V 2.5 does not represent the views and positions of the model developers
+* We will not be liable for any problems arising from the use of the MinCPM-V open Source model, including but not limited to data security issues, risk of public opinion, or any risks and problems arising from the misdirection, misuse, dissemination or misuse of the model.
+
+## Key Techniques and Other Multimodal Projects
+
+👏 Welcome to explore key techniques of MiniCPM-V 2.6 and other multimodal projects of our team:
+
+[VisCPM](https://github.com/OpenBMB/VisCPM/tree/main) | [RLHF-V](https://github.com/RLHF-V/RLHF-V) | [LLaVA-UHD](https://github.com/thunlp/LLaVA-UHD)  | [RLAIF-V](https://github.com/RLHF-V/RLAIF-V)
+
+## Citation
+
+If you find our work helpful, please consider citing our papers 📝 and liking this project ❤️！
+
+```bib
+@article{yao2024minicpmv,
+      title={MiniCPM-V: A GPT-4V Level MLLM on Your Phone}, 
+      author={Yao, Yuan and Yu, Tianyu and Zhang, Ao and Wang, Chongyi and Cui, Junbo and Zhu, Hongji and Cai, Tianchi and Li, Haoyu and Zhao, Weilin and He, Zhihui and Chen, Qianyu and Zhou, Huarong and Zou, Zhensheng and Zhang, Haoye and Hu, Shengding and Zheng, Zhi and Zhou, Jie and Cai, Jie and Han, Xu and Zeng, Guoyang and Li, Dahai and Liu, Zhiyuan and Sun, Maosong},
+      journal={arXiv preprint 2408.01800},
+      year={2024},
+}
+```

config.json

@@ -0,0 +1,55 @@
+{
+  "_name_or_path": "openbmb/MiniCPM-Llama3-V-2_5",
+  "version": "2.5",
+  "architectures": [
+    "MiniCPMV"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "auto_map": {
+    "AutoConfig": "configuration_minicpm.MiniCPMVConfig",
+    "AutoModel": "modeling_minicpmv.MiniCPMV",
+    "AutoModelForCausalLM": "modeling_minicpmv.MiniCPMV"
+  },
+  "batch_vision_input": true,
+  "bos_token_id": 128000,
+  "drop_vision_last_layer": false,
+  "eos_token_id": 128001,
+  "hidden_act": "silu",
+  "hidden_size": 4096,
+  "image_size": 448,
+  "initializer_range": 0.02,
+  "intermediate_size": 14336,
+  "max_position_embeddings": 8192,
+  "mm_use_im_start_end": true,
+  "model_type": "minicpmv",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 8,
+  "patch_size": 14,
+  "pretraining_tp": 1,
+  "query_num": 96,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "rope_theta": 500000.0,
+  "slice_config": {
+    "max_slice_nums": 9,
+    "patch_size": 14,
+    "model_type": "minicpmv"
+  },
+  "slice_mode": true,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.40.0",
+  "use_cache": false,
+  "vision_config": {
+    "hidden_size": 1152,
+    "image_size": 980,
+    "intermediate_size": 4304,
+    "model_type": "idefics2",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 27,
+    "patch_size": 14
+  },
+  "vocab_size": 128256
+}

configuration.json

@@ -0,0 +1 @@
+{"framework":"Pytorch","task":"multimodal-dialogue"}

configuration_minicpm.py

@@ -0,0 +1,113 @@
+# coding=utf-8
+# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.
+#
+# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
+# and OPT implementations in this library. It has been modified from its
+# original forms to accommodate minor architectural differences compared
+# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
+#
+# 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.
+""" MiniCPM model configuration"""
+import os
+from typing import Union
+
+from transformers.utils import logging
+from transformers import LlamaConfig, PretrainedConfig
+from transformers.models.idefics2.modeling_idefics2 import Idefics2VisionConfig
+
+logger = logging.get_logger(__name__)
+
+
+class MiniCPMVSliceConfig(PretrainedConfig):
+    model_type = "minicpmv"
+
+    def __init__(
+        self,
+        patch_size=14,
+        max_slice_nums=9,
+        scale_resolution=448,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.patch_size = patch_size
+        self.max_slice_nums = max_slice_nums
+        self.scale_resolution = scale_resolution
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
+        cls._set_token_in_kwargs(kwargs)
+
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        if config_dict.get("model_type") == "minicpmv":
+            config_dict = config_dict["slice_config"]
+
+        if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
+            logger.warning(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
+            )
+
+        return cls.from_dict(config_dict, **kwargs)
+
+
+
+class MiniCPMVConfig(LlamaConfig):
+    model_type = "minicpmv"
+    keys_to_ignore_at_inference = ["past_key_values"]
+
+    default_vision_config = {
+        "hidden_size": 1152,
+        "image_size": 980,
+        "intermediate_size": 4304,
+        "model_type": "idefics2",
+        "num_attention_heads": 16,
+        "num_hidden_layers": 27,
+        "patch_size": 14,
+    }
+
+    def __init__(
+        self,
+        use_cache=True,
+        query_num=64,
+        image_size=448,
+        drop_vision_last_layer=True,
+        batch_vision_input=True,
+        slice_config=None,
+        vision_config=None,
+        **kwargs,
+    ):
+        self.use_cache = use_cache
+        self.query_num = query_num
+        self.image_size = image_size
+        self.drop_vision_last_layer = drop_vision_last_layer
+        self.batch_vision_input = batch_vision_input
+
+        if slice_config is None:
+            self.slice_config = MiniCPMVSliceConfig(max_slice_nums=1)
+        else:
+            self.slice_config = MiniCPMVSliceConfig(**slice_config)
+        self.slice_mode = True
+
+        # same as HuggingFaceM4/siglip-so400m-14-980-flash-attn2-navit
+        if vision_config is None:
+            self.vision_config = Idefics2VisionConfig(**self.default_vision_config)
+            logger.info("vision_config is None, using default vision config")
+        elif isinstance(vision_config, dict):
+            self.vision_config = Idefics2VisionConfig(**vision_config)
+        elif isinstance(vision_config, Idefics2VisionConfig):
+            self.vision_config = vision_config
+
+        self.patch_size = self.vision_config.patch_size
+
+        super().__init__(**kwargs)

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 128000,
+  "eos_token_id": 128001,
+  "transformers_version": "4.40.0"
+}

image_processing_minicpmv.py

@@ -0,0 +1,402 @@
+from typing import Optional, Union, Dict, Any
+
+import torch
+import math
+import PIL.Image
+import PIL.ImageSequence
+import numpy as np
+import PIL
+from PIL import Image
+
+from transformers.utils import TensorType, requires_backends, is_torch_dtype, is_torch_device
+from transformers.image_processing_utils import BaseImageProcessor, BatchFeature
+from transformers import AutoImageProcessor
+from transformers.image_transforms import to_channel_dimension_format
+from transformers.image_utils import (
+    ImageInput, 
+    make_list_of_images, 
+    valid_images, 
+    is_torch_tensor, 
+    to_numpy_array, 
+    infer_channel_dimension_format,
+    ChannelDimension
+)
+
+
+def recursive_converter(converter, value):
+    if isinstance(value, list):
+        new_value = []
+        for v in value:
+            new_value += [recursive_converter(converter, v)]
+        return new_value
+    else:
+        return converter(value)
+
+
+class MiniCPMVBatchFeature(BatchFeature):
+    r"""
+    Extend from BatchFeature for supporting various image size
+    """
+    def __init__(self, data: Optional[Dict[str, Any]] = None, tensor_type: Union[None, str, TensorType] = None):
+        super().__init__(data)
+        self.convert_to_tensors(tensor_type=tensor_type)
+
+    def convert_to_tensors(self, tensor_type: Optional[Union[str, TensorType]] = None):
+        if tensor_type is None:
+            return self
+        
+        is_tensor, as_tensor = self._get_is_as_tensor_fns(tensor_type)
+
+        def converter(value):
+            try:
+                if not is_tensor(value):
+                    tensor = as_tensor(value)
+                    return tensor
+            except:  # noqa E722
+                if key == "overflowing_values":
+                    raise ValueError("Unable to create tensor returning overflowing values of different lengths. ")
+                raise ValueError(
+                    "Unable to create tensor, you should probably activate padding "
+                    "with 'padding=True' to have batched tensors with the same length."
+                )
+
+
+        for key, value in self.items():
+            self[key] = recursive_converter(converter, value)
+        return self
+            
+    def to(self, *args, **kwargs) -> "MiniCPMVBatchFeature":
+        requires_backends(self, ["torch"])
+        import torch
+
+        def cast_tensor(v):
+            # check if v is a floating point
+            if torch.is_floating_point(v):
+                # cast and send to device
+                return v.to(*args, **kwargs)
+            elif device is not None:
+                return v.to(device=device)
+            else:
+                return v
+
+        new_data = {}
+        device = kwargs.get("device")
+        # Check if the args are a device or a dtype
+        if device is None and len(args) > 0:
+            # device should be always the first argument
+            arg = args[0]
+            if is_torch_dtype(arg):
+                # The first argument is a dtype
+                pass
+            elif isinstance(arg, str) or is_torch_device(arg) or isinstance(arg, int):
+                device = arg
+            else:
+                # it's something else
+                raise ValueError(f"Attempting to cast a BatchFeature to type {str(arg)}. This is not supported.")
+        # We cast only floating point tensors to avoid issues with tokenizers casting `LongTensor` to `FloatTensor`
+        for k, v in self.items():
+            new_data[k] = recursive_converter(cast_tensor, v)
+        self.data = new_data
+        return self
+
+
+class MiniCPMVImageProcessor(BaseImageProcessor):
+    model_input_names = ["pixel_values"]
+
+    def __init__(
+            self, 
+            max_slice_nums=9,
+            scale_resolution=448,
+            patch_size=14,
+            **kwargs):
+        super().__init__(**kwargs)
+        self.max_slice_nums = max_slice_nums
+        self.scale_resolution = scale_resolution
+        self.patch_size = patch_size
+        self.image_feature_size = kwargs.pop("image_feature_size", 64)
+        self.im_start_token = kwargs.pop("im_start", "<image>")
+        self.im_end_token = kwargs.pop("im_end", "</image>")
+        self.slice_start_token = kwargs.pop("slice_start", "<slice>")
+        self.slice_end_token = kwargs.pop("slice_end", "</slice>")
+        self.unk_token = kwargs.pop("unk", "<unk>")
+        self.mean = np.array(kwargs.pop("norm_mean", [0.5, 0.5, 0.5]))
+        self.std = np.array(kwargs.pop("norm_std", [0.5, 0.5, 0.5]))
+        self.version = kwargs.pop("version", 2.0)
+
+    def ensure_divide(self, length, patch_size):
+        return max(round(length / patch_size) * patch_size, patch_size)
+
+    def find_best_resize(self,
+                         original_size,
+                         scale_resolution,
+                         patch_size,
+                         allow_upscale=False):
+        width, height = original_size
+        if (width * height >
+                scale_resolution * scale_resolution) or allow_upscale:
+            r = width / height
+            height = int(scale_resolution / math.sqrt(r))
+            width = int(height * r)
+        best_width = self.ensure_divide(width, patch_size)
+        best_height = self.ensure_divide(height, patch_size)
+        return (best_width, best_height)
+
+    def get_refine_size(self,
+                        original_size,
+                        grid,
+                        scale_resolution,
+                        patch_size,
+                        allow_upscale=False):
+        width, height = original_size
+        grid_x, grid_y = grid
+
+        refine_width = self.ensure_divide(width, grid_x)
+        refine_height = self.ensure_divide(height, grid_y)
+
+        grid_width = refine_width / grid_x
+        grid_height = refine_height / grid_y
+
+        best_grid_size = self.find_best_resize((grid_width, grid_height),
+                                               scale_resolution,
+                                               patch_size,
+                                               allow_upscale=allow_upscale)
+        refine_size = (best_grid_size[0] * grid_x, best_grid_size[1] * grid_y)
+        return refine_size
+
+    def split_to_patches(self, image, grid):
+        patches = []
+        width, height = image.size
+        grid_x = int(width / grid[0])
+        grid_y = int(height / grid[1])
+        for i in range(0, height, grid_y):
+            images = []
+            for j in range(0, width, grid_x):
+                box = (j, i, j + grid_x, i + grid_y)
+                patch = image.crop(box)
+                images.append(patch)
+            patches.append(images)
+        return patches
+
+    def slice_image(
+        self, image, max_slice_nums=9, scale_resolution=448, patch_size=14, never_split=False
+    ):
+        original_size = image.size
+        original_width, original_height = original_size
+        log_ratio = math.log(original_width / original_height)
+        ratio = original_width * original_height / (scale_resolution * scale_resolution)
+        multiple = min(math.ceil(ratio), max_slice_nums)
+
+        source_image = None
+        best_grid = None
+        patches = []
+
+        if multiple <= 1 or never_split:
+            # dont need to slice, upsample
+            best_size = self.find_best_resize(
+                original_size, scale_resolution, patch_size, allow_upscale=True
+            )
+            source_image = image.resize(best_size, resample=Image.Resampling.BICUBIC)
+        else:
+            candidate_split_grids_nums = []
+            for i in [multiple - 1, multiple, multiple + 1]:
+                if i == 1 or i > max_slice_nums:
+                    continue
+                candidate_split_grids_nums.append(i)
+
+            # source image, down-sampling and ensure divided by patch_size
+            best_resize = self.find_best_resize(original_size, scale_resolution, patch_size)
+            source_image = image.copy().resize(best_resize, resample=Image.Resampling.BICUBIC)
+            candidate_grids = []
+
+            # find best grid
+            for split_grids_nums in candidate_split_grids_nums:
+                m = 1
+                while m <= split_grids_nums:
+                    if split_grids_nums % m == 0:
+                        candidate_grids.append([m, split_grids_nums // m])
+                    m += 1
+
+            best_grid = [1, 1]
+            min_error = float("inf")
+            for grid in candidate_grids:
+                error = abs(log_ratio - math.log(grid[0] / grid[1]))
+                if error < min_error:
+                    best_grid = grid
+                    min_error = error
+
+            refine_size = self.get_refine_size(
+                original_size, best_grid, scale_resolution, patch_size, allow_upscale=True
+            )
+
+            refine_image = image.resize(refine_size, resample=Image.Resampling.BICUBIC)
+            patches = self.split_to_patches(refine_image, best_grid)
+
+        return source_image, patches, best_grid
+
+    def get_grid_placeholder(self, grid):
+        if grid is None:
+            return ""
+        image_placeholder = (
+            self.im_start_token 
+            + self.unk_token * self.image_feature_size
+            + self.im_end_token
+        )
+
+        cols = grid[0]
+        rows = grid[1]
+        slices = []
+        for i in range(rows):
+            lines = []
+            for j in range(cols):
+                lines.append(image_placeholder)
+            slices.append("".join(lines))
+            
+        slice_placeholder = self.slice_start_token + "\n".join(slices) + self.slice_end_token
+        return slice_placeholder
+
+    def get_sliced_images(self, image):
+        slice_images = []
+
+        source_image, patches, sliced_grid = self.slice_image(
+            image,
+            self.max_slice_nums,  # default: 9
+            self.scale_resolution,  # default: 448
+            self.patch_size  # default: 14
+        )
+        slice_images.append(source_image)
+
+        if len(patches) > 0:
+            for i in range(len(patches)):
+                for j in range(len(patches[0])):
+                    slice_images.append(patches[i][j])
+        return slice_images
+
+    def get_sliced_grid(self, image_size):
+        original_width, original_height = image_size
+        log_ratio = math.log(original_width / original_height)
+        ratio = original_width * original_height / (self.scale_resolution * self.scale_resolution)
+        multiple = min(math.ceil(ratio), self.max_slice_nums)
+        if multiple <= 1:
+            return None
+        candidate_split_grids_nums = []
+        for i in [multiple - 1, multiple, multiple + 1]:
+            if i == 1 or i > self.max_slice_nums:
+                continue
+            candidate_split_grids_nums.append(i)
+        
+        candidate_grids = []
+        for split_grids_nums in candidate_split_grids_nums:
+            m = 1
+            while m <= split_grids_nums:
+                if split_grids_nums % m == 0:
+                    candidate_grids.append([m, split_grids_nums // m])
+                m += 1
+
+        best_grid = [1, 1]
+        min_error = float("inf")
+        for grid in candidate_grids:
+            error = abs(log_ratio - math.log(grid[0] / grid[1]))
+            if error < min_error:
+                best_grid = grid
+                min_error = error
+        
+        return best_grid
+
+    def get_slice_image_placeholder(self, image_size):
+        grid = self.get_sliced_grid(image_size=image_size)
+        return (
+            self.im_start_token 
+            + self.unk_token * self.image_feature_size 
+            + self.im_end_token
+        ) + self.get_grid_placeholder(grid=grid)
+
+    def to_pil_image(self, image, rescale=None) -> PIL.Image.Image:
+        """
+        Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if
+        needed.
+
+        Args:
+            image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor`):
+                The image to convert to the PIL Image format.
+            rescale (`bool`, *optional*):
+                Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will
+                default to `True` if the image type is a floating type, `False` otherwise.
+        """
+        if isinstance(image, PIL.Image.Image):
+            return image
+        if is_torch_tensor(image):
+            image = image.numpy()
+
+        if isinstance(image, np.ndarray):
+            if rescale is None:
+                # rescale default to the array being of floating type.
+                rescale = isinstance(image.flat[0], np.floating)
+            # If the channel as been moved to first dim, we put it back at the end.
+            if image.ndim == 3 and image.shape[0] in [1, 3]:
+                image = image.transpose(1, 2, 0)
+            if rescale:
+                image = image * 255
+            image = image.astype(np.uint8)
+            return PIL.Image.fromarray(image)
+        return image
+
+    def reshape_by_patch(self, image):
+        """
+        :param image: shape [3, H, W]
+        :param patch_size:
+        :return: [3, patch_size, HW/patch_size]
+        """
+        image = torch.from_numpy(image)
+        patch_size = self.patch_size
+        patches = torch.nn.functional.unfold(
+            image,
+            (patch_size, patch_size),
+            stride=(patch_size, patch_size)
+        )
+
+        patches = patches.reshape(image.size(0), patch_size, patch_size, -1)
+        patches = patches.permute(0, 1, 3, 2).reshape(image.size(0), patch_size, -1)
+        return patches.numpy()
+
+    def preprocess(
+            self, 
+            images: ImageInput,
+            do_pad: Optional[bool] = True, # TODO: add pad for MiniCPM-Llama3-V-2_5
+            return_tensors: Optional[Union[str, TensorType]] = None
+        ) -> MiniCPMVBatchFeature:
+        images = make_list_of_images(images)
+
+        if not valid_images(images):
+            raise ValueError(
+                "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
+                "torch.Tensor, tf.Tensor or jax.ndarray."
+            )
+        
+        images = [self.to_pil_image(image).convert("RGB") for image in images]
+        input_data_format = infer_channel_dimension_format(np.array(images[0]))
+
+        new_images = []
+        image_sizes = [image.size for image in images]
+        tgt_sizes = []
+        for image in images:
+            image_patches = self.get_sliced_images(image)
+            image_patches = [to_numpy_array(image).astype(np.float32) / 255 for image in image_patches]
+            image_patches = [
+                self.normalize(image=image, mean=self.mean, std=self.std, input_data_format=input_data_format)
+                    for image in image_patches
+            ]
+            image_patches = [
+                to_channel_dimension_format(image, ChannelDimension.FIRST, input_channel_dim=input_data_format) 
+                    for image in image_patches
+            ]
+            for slice_image in image_patches:
+                new_images.append(self.reshape_by_patch(slice_image))
+                tgt_sizes.append(np.array((slice_image.shape[1] // self.patch_size, slice_image.shape[2] // self.patch_size)))
+
+        if tgt_sizes:
+            tgt_sizes = np.vstack(tgt_sizes)
+        return MiniCPMVBatchFeature(
+            data={"pixel_values": [new_images], "image_sizes": [image_sizes], "tgt_sizes": [tgt_sizes]}, tensor_type=return_tensors
+        )
+
+AutoImageProcessor.register("MiniCPMVImageProcessor", MiniCPMVImageProcessor)

model-00001-of-00007.safetensors

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

model-00002-of-00007.safetensors

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

model-00003-of-00007.safetensors

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

model-00004-of-00007.safetensors

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

model-00005-of-00007.safetensors

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

model-00006-of-00007.safetensors

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

model-00007-of-00007.safetensors

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

model.safetensors.index.json

@@ -0,0 +1,748 @@
+{
+  "metadata": {
+    "total_size": 34148369344
+  },
+  "weight_map": {
+    "llm.lm_head.weight": "model-00007-of-00007.safetensors",
+    "llm.model.embed_tokens.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.0.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.1.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.10.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.10.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.11.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.12.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.13.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.14.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.14.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.14.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.14.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.14.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.14.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.14.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.14.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.14.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.15.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.15.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.16.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.17.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.18.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.19.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.2.input_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.mlp.down_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.mlp.gate_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.mlp.up_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.post_attention_layernorm.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.2.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.20.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.20.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.20.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.20.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.20.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.20.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.20.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.20.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.20.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "llm.model.layers.21.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.21.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.22.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.23.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.24.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.25.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.25.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.25.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.25.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "llm.model.layers.26.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.26.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.27.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.28.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.29.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.3.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.3.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.3.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.3.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.3.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.3.self_attn.k_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.3.self_attn.o_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.3.self_attn.q_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.3.self_attn.v_proj.weight": "model-00001-of-00007.safetensors",
+    "llm.model.layers.30.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.30.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.31.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "llm.model.layers.31.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "llm.model.layers.31.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.31.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "llm.model.layers.31.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "llm.model.layers.31.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.31.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.31.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.31.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "llm.model.layers.4.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.4.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.5.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.6.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.7.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.8.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.8.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.8.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.8.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "llm.model.layers.9.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.layers.9.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "llm.model.norm.weight": "model-00007-of-00007.safetensors",
+    "resampler.attn.in_proj_bias": "model-00007-of-00007.safetensors",
+    "resampler.attn.in_proj_weight": "model-00007-of-00007.safetensors",
+    "resampler.attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "resampler.attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "resampler.kv_proj.weight": "model-00007-of-00007.safetensors",
+    "resampler.ln_kv.bias": "model-00007-of-00007.safetensors",
+    "resampler.ln_kv.weight": "model-00007-of-00007.safetensors",
+    "resampler.ln_post.bias": "model-00007-of-00007.safetensors",
+    "resampler.ln_post.weight": "model-00007-of-00007.safetensors",
+    "resampler.ln_q.bias": "model-00007-of-00007.safetensors",
+    "resampler.ln_q.weight": "model-00007-of-00007.safetensors",
+    "resampler.proj": "model-00007-of-00007.safetensors",
+    "resampler.query": "model-00007-of-00007.safetensors",
+    "vpm.embeddings.patch_embedding.bias": "model-00007-of-00007.safetensors",
+    "vpm.embeddings.patch_embedding.weight": "model-00007-of-00007.safetensors",
+    "vpm.embeddings.position_embedding.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.0.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.1.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.10.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.11.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.12.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.13.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.14.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.15.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.16.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.17.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.18.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.19.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.2.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.20.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.21.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.22.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.23.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.24.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.25.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.26.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.3.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.4.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.5.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.6.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.7.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.8.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.layer_norm1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.layer_norm1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.layer_norm2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.layer_norm2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.mlp.fc1.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.mlp.fc1.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.mlp.fc2.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.mlp.fc2.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.k_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.out_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.out_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.q_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.v_proj.bias": "model-00007-of-00007.safetensors",
+    "vpm.encoder.layers.9.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "vpm.post_layernorm.bias": "model-00007-of-00007.safetensors",
+    "vpm.post_layernorm.weight": "model-00007-of-00007.safetensors"
+  }
+}

modeling_minicpmv.py

@@ -0,0 +1,364 @@
+import math
+import json
+import torch
+from threading import Thread
+from copy import deepcopy
+from PIL import Image
+from torchvision import transforms
+from transformers import LlamaPreTrainedModel, LlamaForCausalLM, TextIteratorStreamer
+from transformers.models.idefics2.modeling_idefics2 import Idefics2VisionTransformer
+from transformers import AutoProcessor
+
+from .configuration_minicpm import MiniCPMVConfig
+from .resampler import Resampler
+
+IMAGENET_INCEPTION_MEAN = (0.5, 0.5, 0.5) # timm.data.IMAGENET_INCEPTION_MEAN
+IMAGENET_INCEPTION_STD = (0.5, 0.5, 0.5)  # timm.data.IMAGENET_INCEPTION_STD
+
+class MiniCPMVPreTrainedModel(LlamaPreTrainedModel):
+    config_class = MiniCPMVConfig
+
+
+class MiniCPMV(MiniCPMVPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.llm = LlamaForCausalLM(config)
+        self.vpm = self.init_vision_module()
+        self.vision_dim = self.vpm.embed_dim
+        self.embed_dim = self.llm.config.hidden_size
+        self.resampler = self.init_resampler(self.embed_dim, self.vision_dim)
+        self.transform = self.init_transform()
+
+    def init_vision_module(self):
+        # same as HuggingFaceM4/siglip-so400m-14-980-flash-attn2-navit
+        model = Idefics2VisionTransformer(self.config.vision_config)
+        if self.config.drop_vision_last_layer:
+            model.encoder.layers = model.encoder.layers[:-1]
+
+        setattr(model, 'embed_dim', model.embeddings.embed_dim)
+        setattr(model, 'patch_size', model.embeddings.patch_size)
+
+        return model
+
+    def init_resampler(self, embed_dim, vision_dim):
+        return Resampler(
+            num_queries=self.config.query_num,
+            embed_dim=embed_dim,
+            num_heads=embed_dim // 128,
+            kv_dim=vision_dim,
+            adaptive=True
+        )
+
+    def init_transform(self):
+        return transforms.Compose(
+            [
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=IMAGENET_INCEPTION_MEAN, std=IMAGENET_INCEPTION_STD
+                ),
+            ]
+        )
+
+    def get_input_embeddings(self):
+        return self.llm.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.llm.embed_tokens = value
+
+    def get_output_embeddings(self):
+        return self.llm.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.llm.lm_head = new_embeddings
+
+    def set_decoder(self, decoder):
+        self.llm = decoder
+
+    def get_decoder(self):
+        return self.llm
+
+    def get_vllm_embedding(self, data):
+        if 'vision_hidden_states' not in data:
+            dtype = self.llm.model.embed_tokens.weight.dtype
+            device = self.llm.model.embed_tokens.weight.device
+            tgt_sizes = data['tgt_sizes']
+            pixel_values_list = data['pixel_values']
+            vision_hidden_states = []
+            all_pixel_values = []
+            img_cnt = []
+            for pixel_values in pixel_values_list:
+                img_cnt.append(len(pixel_values))
+                all_pixel_values.extend([i.flatten(end_dim=1).permute(1, 0) for i in pixel_values])
+                
+            # exist image
+            if all_pixel_values:
+                tgt_sizes = torch.vstack(tgt_sizes).type(torch.int32)
+
+                if self.config.batch_vision_input:
+                    max_patches = torch.max(tgt_sizes[:, 0] * tgt_sizes[:, 1])
+
+                    all_pixel_values = torch.nn.utils.rnn.pad_sequence(all_pixel_values, batch_first=True,
+                                                                       padding_value=0.0)
+                    B, L, _ = all_pixel_values.shape
+                    all_pixel_values = all_pixel_values.permute(0, 2, 1).reshape(B, 3, -1, L)
+
+                    patch_attn_mask = torch.zeros((B, 1, max_patches), dtype=torch.bool, device=device)
+                    for i in range(B):
+                        patch_attn_mask[i, :tgt_sizes[i][0] * tgt_sizes[i][1]] = True
+
+                    vision_embedding = self.vpm(all_pixel_values.type(dtype), patch_attention_mask=patch_attn_mask).last_hidden_state
+                    vision_embedding = self.resampler(vision_embedding, tgt_sizes)
+                else:
+                    # get vision_embedding foreach
+                    vision_embedding = []
+                    for single_tgt_size, single_pixel_values in zip(tgt_sizes, all_pixel_values):
+                        single_pixel_values = single_pixel_values.unsqueeze(0)
+                        B, L, _ = single_pixel_values.shape
+                        single_pixel_values = single_pixel_values.permute(0, 2, 1).reshape(B, 3, -1, L)
+                        single_vision_embedding = self.vpm(single_pixel_values.type(dtype)).last_hidden_state
+                        single_vision_embedding = self.resampler(single_vision_embedding, single_tgt_size.unsqueeze(0))
+                        vision_embedding.append(single_vision_embedding)
+                    vision_embedding = torch.vstack(vision_embedding)
+
+                start = 0
+                for pixel_values in pixel_values_list:
+                    img_cnt = len(pixel_values)
+                    if img_cnt > 0:
+                        vision_hidden_states.append(vision_embedding[start: start + img_cnt])
+                        start += img_cnt
+                    else:
+                        vision_hidden_states.append([])
+            else: # no image
+                if self.training:
+                    dummy_image = torch.zeros(
+                        (1, 3, 224, 224),
+                        device=device, dtype=dtype
+                    )
+                    tgt_sizes = torch.Tensor([[(224 // self.config.patch_size), math.ceil(224 / self.config.patch_size)]]).type(torch.int32)
+                    dummy_feature = self.resampler(self.vpm(dummy_image).last_hidden_state, tgt_sizes)
+                else:
+                    dummy_feature = []
+                for _ in range(len(pixel_values_list)):
+                    vision_hidden_states.append(dummy_feature)
+
+        else:
+            vision_hidden_states = data['vision_hidden_states']
+
+        if hasattr(self.llm.config, 'scale_emb'):
+            vllm_embedding = self.llm.model.embed_tokens(data['input_ids']) * self.llm.config.scale_emb
+        else:
+            vllm_embedding = self.llm.model.embed_tokens(data['input_ids'])
+
+        vision_hidden_states = [i.type(vllm_embedding.dtype) if isinstance(
+            i, torch.Tensor) else i for i in vision_hidden_states]
+
+        bs = len(data['input_ids'])
+        for i in range(bs):
+            cur_vs_hs = vision_hidden_states[i]
+            if len(cur_vs_hs) > 0:
+                cur_vllm_emb = vllm_embedding[i]
+                cur_image_bound = data['image_bound'][i]
+                if len(cur_image_bound) > 0:
+                    image_indices = torch.stack(
+                        [torch.arange(r[0], r[1], dtype=torch.long) for r in cur_image_bound]
+                    ).to(vllm_embedding.device)
+
+                    cur_vllm_emb.scatter_(0, image_indices.view(-1, 1).repeat(1, cur_vllm_emb.shape[-1]),
+                                          cur_vs_hs.view(-1, cur_vs_hs.shape[-1]))
+                elif self.training:
+                    cur_vllm_emb += cur_vs_hs[0].mean() * 0
+        
+        return vllm_embedding, vision_hidden_states
+
+    def forward(self, data, **kwargs):
+        vllm_embedding, vision_hidden_states = self.get_vllm_embedding(data)
+        position_ids = data["position_ids"]
+        if position_ids.dtype != torch.int64:
+            position_ids = position_ids.long()
+
+        return self.llm(
+            input_ids=None,
+            position_ids=position_ids,
+            inputs_embeds=vllm_embedding,
+            **kwargs
+        )
+
+    def _decode_text(self, result_ids, tokenizer):
+        result_text = []
+        for result in result_ids:
+            result = result[result != 0]
+            if result[0] == tokenizer.bos_id:
+                result = result[1:]
+            if result[-1] == tokenizer.eos_id or result[-1] == tokenizer.eot_id:
+                result = result[:-1]
+            result_text.append(tokenizer.decode(result).strip())
+        return result_text
+
+    def _decode(self, inputs_embeds, tokenizer, decode_text=False, **kwargs):
+        terminators = [
+            tokenizer.eos_token_id,
+            tokenizer.convert_tokens_to_ids("<|eot_id|>")
+        ]
+        output = self.llm.generate(
+            inputs_embeds=inputs_embeds,
+            pad_token_id=0,
+            eos_token_id=terminators,
+            **kwargs
+        )
+        if decode_text:
+            return self._decode_text(output, tokenizer)
+        return output
+    
+    def _decode_stream(self, inputs_embeds, tokenizer, **kwargs):
+        terminators = [
+            tokenizer.eos_token_id,
+            tokenizer.convert_tokens_to_ids("<|eot_id|>")
+        ]
+        streamer = TextIteratorStreamer(tokenizer=tokenizer)
+        generation_kwargs = {
+            'inputs_embeds': inputs_embeds,
+            'pad_token_id': 0,
+            'eos_token_id': terminators,
+            'streamer': streamer
+        }
+        generation_kwargs.update(kwargs)
+
+        thread = Thread(target=self.llm.generate, kwargs=generation_kwargs)
+        thread.start()
+    
+        return streamer
+
+    def generate(
+        self,
+        model_inputs,
+        tokenizer=None,
+        vision_hidden_states=None,
+        stream=False,
+        **kwargs
+    ):
+        bs = len(model_inputs["input_ids"])
+        img_list = model_inputs["pixel_values"]
+        tgt_sizes = model_inputs["tgt_sizes"]
+        if img_list is None:
+            img_list = [[] for i in range(bs)]
+        assert bs == len(img_list)
+        if vision_hidden_states is None:
+            pixel_values = []
+            for i in range(bs):
+                img_inps = []
+                for img in img_list[i]:
+                    img_inps.append(img.to(self.device))
+                if img_inps:
+                    pixel_values.append(img_inps)
+                else:
+                    pixel_values.append([])
+            model_inputs["pixel_values"] = pixel_values
+            model_inputs['tgt_sizes'] = tgt_sizes
+        else:
+            model_inputs["vision_hidden_states"] = vision_hidden_states
+
+        (
+            input_embeds,
+            vision_hidden_states,
+        ) = self.get_vllm_embedding(model_inputs)            
+
+        # output_ids = self._decode(input_embeds, tokenizer, **kwargs)
+        if stream:
+            kwargs.pop("decode_text")
+            result = self._decode_stream(input_embeds, tokenizer, **kwargs)
+        else:
+            result = self._decode(input_embeds, tokenizer, **kwargs)
+
+        return result
+
+    def chat(
+        self,
+        image,
+        msgs,
+        tokenizer,
+        processor=None,
+        vision_hidden_states=None,
+        max_new_tokens=1024,
+        sampling=True,
+        max_inp_length=2048,
+        system_prompt='',
+        stream=False,
+        **kwargs
+    ):
+        if processor is None:
+            processor = AutoProcessor.from_pretrained(self.config._name_or_path, trust_remote_code=True)
+        if isinstance(msgs, str):
+            msgs = json.loads(msgs)
+        copy_msgs = deepcopy(msgs)
+
+        assert len(msgs) > 0, "msgs is empty"
+        assert sampling or not stream, "if use stream mode, make sure sampling=True"
+
+        if image is not None and isinstance(copy_msgs[0]["content"], str):
+            # copy_msgs[0]['content'] = '(<image>./</image>)\n' + copy_msgs[0]['content']
+            copy_msgs[0]["content"] = [image, copy_msgs[0]["content"]]
+
+        images = []
+        for i, msg in enumerate(copy_msgs):
+            role = msg["role"]
+            content = msg["content"]
+            assert role in ["user", "assistant"]
+            if i == 0:
+                assert role == "user", "The role of first msg should be user"
+            if isinstance(content, str):
+                content = [content]
+            cur_msgs = []
+            for c in content:
+                if isinstance(c, Image.Image):
+                    images.append(c)
+                    cur_msgs.append("(<image>./</image>)")
+                elif isinstance(c, str):
+                    cur_msgs.append(c)
+            msg["content"] = "\n".join(cur_msgs)
+
+        if system_prompt:
+            sys_msg = {'role': 'system', 'content': system_prompt}
+            copy_msgs = [sys_msg] + copy_msgs        
+
+        prompt = processor.tokenizer.apply_chat_template(copy_msgs, tokenize=False, add_generation_prompt=True)
+        inputs = processor(prompt, images, return_tensors="pt", max_length=max_inp_length).to(self.device)
+
+        if sampling:
+            generation_config = {
+                "top_p": 0.8,
+                "top_k": 100,
+                "temperature": 0.7,
+                "do_sample": True,
+                "repetition_penalty": 1.05
+            }
+        else:
+            generation_config = {
+                "num_beams": 3,
+                "repetition_penalty": 1.2,
+            }
+
+        generation_config.update(
+            (k, kwargs[k]) for k in generation_config.keys() & kwargs.keys()
+        )
+        with torch.inference_mode():
+            res = self.generate(
+                inputs,
+                tokenizer=tokenizer,
+                max_new_tokens=max_new_tokens,
+                vision_hidden_states=vision_hidden_states,
+                stream=stream,
+                decode_text=True,
+                **generation_config
+            )
+        
+        if stream:
+            def stream_gen():
+                for text in res:
+                    text = text.replace(tokenizer.eot_token, '').replace(tokenizer.eos_token, '')
+                    yield text
+            return stream_gen()
+
+        else:
+            answer = res[0]
+            return answer

preprocessor_config.json

@@ -0,0 +1,20 @@
+{
+    "image_processor_type": "MiniCPMVImageProcessor",
+    "auto_map": {
+        "AutoProcessor": "processing_minicpmv.MiniCPMVProcessor",
+        "AutoImageProcessor": "image_processing_minicpmv.MiniCPMVImageProcessor"
+      },
+    "processor_class": "MiniCPMVProcessor",
+    "max_slice_nums": 9,
+    "scale_resolution": 448,
+    "patch_size": 14,
+    "image_feature_size": 96,
+    "im_start": "<image>",
+    "im_end": "</image>",
+    "slice_start": "<slice>",
+    "slice_end": "</slice>",
+    "unk": "<unk>",
+    "norm_mean": [0.5, 0.5, 0.5],
+    "norm_std": [0.5, 0.5, 0.5],
+    "version": 2.5
+}

processing_minicpmv.py

@@ -0,0 +1,244 @@
+# coding=utf-8
+# Copyright 2024 The HuggingFace Inc. 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.
+"""
+Processor class for MiniCPMV.
+"""
+
+from typing import List, Optional, Union, Dict, Any
+import torch
+import re
+
+from transformers.image_processing_utils import BatchFeature
+from transformers.image_utils import ImageInput
+from transformers.processing_utils import ProcessorMixin
+from transformers.tokenization_utils_base import PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
+from transformers.utils import TensorType, requires_backends, is_torch_dtype, is_torch_device
+
+from .image_processing_minicpmv import MiniCPMVBatchFeature
+
+
+class MiniCPMVProcessor(ProcessorMixin):
+    r"""
+    Constructs a MiniCPMV processor which wraps a MiniCPMV image processor and a MiniCPMV tokenizer into a single processor.
+
+    [`MiniCPMVProcessor`] offers all the functionalities of [`MiniCPMVImageProcessor`] and [`LlamaTokenizerWrapper`]. See the
+    [`~MiniCPMVProcessor.__call__`] and [`~MiniCPMVProcessor.decode`] for more information.
+
+    Args:
+        image_processor ([`MiniCPMVImageProcessor`], *optional*):
+            The image processor is a required input.
+        tokenizer ([`LlamaTokenizerWrapper`], *optional*):
+            The tokenizer is a required input.
+    """
+    attributes = ["image_processor", "tokenizer"]
+    image_processor_class = "AutoImageProcessor"
+    tokenizer_class = "AutoTokenizer"
+
+    def __init__(self, image_processor=None, tokenizer=None):
+        super().__init__(image_processor, tokenizer)
+        self.version = image_processor.version
+    
+    def __call__(
+        self,
+        text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]],
+        images: ImageInput = None,
+        padding: Union[bool, str, PaddingStrategy] = False,
+        truncation: Union[bool, str, TruncationStrategy] = None,
+        max_length: Optional[int] = None,
+        do_pad: Optional[bool] = True,
+        return_tensors: Optional[Union[str, TensorType]] = TensorType.PYTORCH,
+    ) -> MiniCPMVBatchFeature:
+        """
+        Only support for single input for now. Batched input is coming soon.
+
+        Args:
+            text (`str`):
+                The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
+                (pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set
+                `is_split_into_words=True` (to lift the ambiguity with a batch of sequences).
+            images (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`, `List[PIL.Image.Image]`, `List[np.ndarray]`, `List[torch.Tensor]`):
+                The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
+                tensor. Both channels-first and channels-last formats are supported.
+            padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
+                Select a strategy to pad the returned sequences (according to the model's padding side and padding
+                index) among:
+                - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
+                  sequence if provided).
+                - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
+                  acceptable input length for the model if that argument is not provided.
+                - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
+                  lengths).
+            max_length (`int`, *optional*):
+                Maximum length of the returned list and optionally padding length (see above).
+            do_pad (`bool`, *optional*, defaults to self.do_pad):
+                Whether to pad the image. If `True` will pad the images in the batch to the largest image in the batch
+                and create a pixel mask. Padding will be applied to the bottom and right of the image with zeros.
+            truncation (`bool`, *optional*):
+                Activates truncation to cut input sequences longer than `max_length` to `max_length`.
+            return_tensors (`str` or [`~utils.TensorType`], *optional*):
+                If set, will return tensors of a particular framework. Acceptable values are:
+
+                - `'tf'`: Return TensorFlow `tf.constant` objects.
+                - `'pt'`: Return PyTorch `torch.Tensor` objects.
+                - `'np'`: Return NumPy `np.ndarray` objects.
+                - `'jax'`: Return JAX `jnp.ndarray` objects.
+
+        Returns:
+            [`BatchFeature`]: A [`BatchFeature`] with the following fields:
+
+            - **input_ids** -- List of token ids to be fed to a model. Returned when `text` is not `None`.
+            - **attention_mask** -- List of indices specifying which tokens should be attended to by the model (when
+              `return_attention_mask=True` or if *"attention_mask"* is in `self.model_input_names` and if `text` is not
+              `None`).
+            - **pixel_values** -- Pixel values to be fed to a model. Returned when `images` is not `None`.
+        """
+        if images is not None:
+            image_inputs = self.image_processor(images, do_pad=do_pad, return_tensors=return_tensors)
+        return self._convert_images_texts_to_inputs(image_inputs, text, max_length=max_length)
+    
+    # Copied from transformers.models.clip.processing_clip.CLIPProcessor.batch_decode with CLIP->Llama
+    def batch_decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to LlamaTokenizerFast's [`~PreTrainedTokenizer.batch_decode`]. Please
+        refer to the docstring of this method for more information.
+        """
+        output_ids = args[0]
+        result_text = []
+        for result in output_ids:
+            result = result[result != 0]
+            if result[0] == self.tokenizer.bos_id:
+                result = result[1:]
+            if result[-1] == self.tokenizer.eos_id:
+                result = result[:-1]
+            result_text.append(self.tokenizer.decode(result, *args[1:], **kwargs).strip())
+        return result_text
+        # return self.tokenizer.batch_decode(*args, **kwargs)
+    
+    # Copied from transformers.models.clip.processing_clip.CLIPProcessor.decode with CLIP->Llama
+    def decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to LlamaTokenizerFast's [`~PreTrainedTokenizer.decode`]. Please refer to
+        the docstring of this method for more information.
+        """
+        result = args[0]
+        result = result[result != 0]
+        if result[0] == self.tokenizer.bos_id:
+            result = result[1:]
+        if result[-1] == self.tokenizer.eos_id or (hasattr(self.tokenizer, "eot_id") and result[-1] == self.tokenizer.eot_id):
+            result = result[:-1]
+        return self.tokenizer.decode(result, *args[1:], **kwargs).strip()
+
+    def _convert(
+        self, input_str, max_inp_length: Optional[int] = None
+    ):
+        if self.version == 2.5 or self.tokenizer.add_bos_token:
+            input_ids = self.tokenizer.encode(input_str)
+        else:
+            input_ids = [self.tokenizer.bos_id] + self.tokenizer.encode(input_str)
+        if max_inp_length is not None:
+            input_ids = input_ids[:max_inp_length]
+        input_ids = torch.tensor(input_ids, dtype=torch.int32)
+
+        image_start_tokens = torch.where(input_ids == self.tokenizer.im_start_id)[0]
+        image_start_tokens += 1
+        image_end_tokens = torch.where(input_ids == self.tokenizer.im_end_id)[0]
+        valid_image_nums = max(len(image_start_tokens), len(image_end_tokens))
+        image_bounds = torch.hstack(
+            [
+                image_start_tokens[:valid_image_nums].unsqueeze(-1),
+                image_end_tokens[:valid_image_nums].unsqueeze(-1),
+            ]
+        )
+        return input_ids.unsqueeze(0), image_bounds
+
+    def _convert_images_texts_to_inputs(self, images, texts, do_pad=False, truncation=None, max_length=None, return_tensors=None):
+        if not len(images):
+            model_inputs = self.tokenizer(texts, return_tensors=return_tensors, padding=do_pad, truncation=truncation, max_length=max_length)
+            return MiniCPMVBatchFeature(data={**model_inputs})
+        
+        pattern = "(<image>./</image>)"
+        images, image_sizes, tgt_sizes = images["pixel_values"], images["image_sizes"], images["tgt_sizes"]
+
+        image_tags = re.findall(pattern, texts)
+        assert len(image_tags) == len(image_sizes[0])
+        text_chunks = texts.split(pattern)
+        final_texts = ""
+        for i in range(len(image_tags)):
+            final_texts = final_texts + text_chunks[i] + self.image_processor.get_slice_image_placeholder(image_sizes[0][i])
+        final_texts += text_chunks[-1]
+        input_ids, image_bounds = self._convert(final_texts, max_length)
+        return MiniCPMVBatchFeature(data={
+            "input_ids": input_ids,
+            "pixel_values": images,
+            "image_sizes": image_sizes,
+            "image_bound": [image_bounds],
+            "tgt_sizes": tgt_sizes
+        })
+
+    @property
+    # Copied from transformers.models.clip.processing_clip.CLIPProcessor.model_input_names
+    def model_input_names(self):
+        tokenizer_input_names = self.tokenizer.model_input_names
+        image_processor_input_names = self.image_processor.model_input_names
+        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))
+
+
+    def pad(self, orig_items, key, max_length=None, padding_value=0, padding_side="left"):
+        items = []
+        if isinstance(orig_items[0][key], list):
+            assert isinstance(orig_items[0][key][0], torch.Tensor)
+            for it in orig_items:
+                for tr in it[key]:
+                    items.append({key: tr})
+        else:
+            assert isinstance(orig_items[0][key], torch.Tensor)
+            items = orig_items
+
+        batch_size = len(items)
+        shape = items[0][key].shape
+        dim = len(shape)
+        assert dim <= 3
+        if max_length is None:
+            max_length = 0
+        max_length = max(max_length, max(item[key].shape[-1] for item in items))
+        min_length = min(item[key].shape[-1] for item in items)
+        dtype = items[0][key].dtype
+
+        if dim == 1:
+            return torch.cat([item[key] for item in items], dim=0)
+        elif dim == 2:
+            if max_length == min_length:
+                return torch.cat([item[key] for item in items], dim=0)
+            tensor = torch.zeros((batch_size, max_length), dtype=dtype) + padding_value
+        else:
+            tensor = (
+                torch.zeros((batch_size, max_length, shape[-1]), dtype=dtype)
+                + padding_value
+            )
+
+        for i, item in enumerate(items):
+            if dim == 2:
+                if padding_side == "left":
+                    tensor[i, -len(item[key][0]) :] = item[key][0].clone()
+                else:
+                    tensor[i, : len(item[key][0])] = item[key][0].clone()
+            elif dim == 3:
+                if padding_side == "left":
+                    tensor[i, -len(item[key][0]) :, :] = item[key][0].clone()
+                else:
+                    tensor[i, : len(item[key][0]), :] = item[key][0].clone()
+
+        return tensor
+    

resampler.py

@@ -0,0 +1,812 @@
+from functools import partial
+import numpy as np
+import warnings
+from typing import Optional, Tuple
+import torch
+from torch import nn
+from torch import Tensor
+import torch.nn.functional as F 
+from torch.nn.functional import *
+from torch.nn.modules.activation import *
+from torch.nn.init import trunc_normal_
+from torch.nn.init import constant_, xavier_normal_, xavier_uniform_
+from transformers import PreTrainedModel
+from transformers.integrations import is_deepspeed_zero3_enabled
+
+def get_2d_sincos_pos_embed(embed_dim, image_size):
+    """
+    image_size: image_size or (image_height, image_width)
+    return:
+    pos_embed: [image_height, image_width, embed_dim]
+    """
+    if isinstance(image_size, int):
+        grid_h_size, grid_w_size = image_size, image_size
+    else:
+        grid_h_size, grid_w_size = image_size[0], image_size[1]
+
+    grid_h = np.arange(grid_h_size, dtype=np.float32)
+    grid_w = np.arange(grid_w_size, dtype=np.float32)
+    grid = np.meshgrid(grid_w, grid_h)  # here w goes first
+    grid = np.stack(grid, axis=0)
+
+    pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+    return pos_embed
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+    assert embed_dim % 2 == 0
+
+    # use half of dimensions to encode grid_h
+    emb_h = get_1d_sincos_pos_embed_from_grid_new(embed_dim // 2, grid[0])  # (H, W, D/2)
+    emb_w = get_1d_sincos_pos_embed_from_grid_new(embed_dim // 2, grid[1])  # (H, W, D/2)
+
+    emb = np.concatenate([emb_h, emb_w], axis=-1)  # (H, W, D)
+    return emb
+
+
+def get_1d_sincos_pos_embed_from_grid_new(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (H, W)
+    out: (H, W, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float32)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000 ** omega  # (D/2,)
+
+    out = np.einsum('hw,d->hwd', pos, omega)  # (H, W, D/2), outer product
+
+    emb_sin = np.sin(out)  # (H, W, D/2)
+    emb_cos = np.cos(out)  # (H, W, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=-1)  # (H, W, D)
+    return emb
+
+    
+class Resampler(nn.Module):
+    """
+    A 2D perceiver-resampler network with one cross attention layers by
+       given learnable queries and 2d sincos pos_emb
+    Outputs:
+        A tensor with the shape of (batch_size, num_queries, embed_dim)
+    """
+
+    def __init__(
+            self,
+            num_queries,
+            embed_dim,
+            num_heads,
+            kv_dim=None,
+            norm_layer=partial(nn.LayerNorm, eps=1e-6),
+            adaptive=False,
+            max_size=(70, 70),
+    ):
+        super().__init__()
+        self.num_queries = num_queries
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.adaptive = adaptive
+        self.max_size = max_size
+
+        self.query = nn.Parameter(torch.zeros(self.num_queries, embed_dim))
+
+        if kv_dim is not None and kv_dim != embed_dim:
+            self.kv_proj = nn.Linear(kv_dim, embed_dim, bias=False)
+        else:
+            self.kv_proj = nn.Identity()
+
+        self.attn = MultiheadAttention(embed_dim, num_heads)
+        self.ln_q = norm_layer(embed_dim)
+        self.ln_kv = norm_layer(embed_dim)
+
+        self.ln_post = norm_layer(embed_dim)
+        self.proj = nn.Parameter((embed_dim ** -0.5) * torch.randn(embed_dim, embed_dim))
+
+        self._set_2d_pos_cache(self.max_size)
+
+    def _set_2d_pos_cache(self, max_size, device='cpu'):
+        if is_deepspeed_zero3_enabled():
+            device='cuda'
+        pos_embed = torch.from_numpy(get_2d_sincos_pos_embed(self.embed_dim, max_size)).float().to(device)
+        self.register_buffer("pos_embed", pos_embed, persistent=False)
+
+    def _adjust_pos_cache(self, tgt_sizes, device):
+        max_h = torch.max(tgt_sizes[:, 0])
+        max_w = torch.max(tgt_sizes[:, 1])
+        if max_h > self.max_size[0] or max_w > self.max_size[1]:
+            self.max_size = [max(max_h, self.max_size[0]), max(max_w, self.max_size[1])]
+            self._set_2d_pos_cache(self.max_size, device)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def forward(self, x, tgt_sizes=None):
+        assert x.shape[0] == tgt_sizes.shape[0]
+        bs = x.shape[0]
+
+        device = x.device
+        dtype = x.dtype
+
+        patch_len = tgt_sizes[:, 0] * tgt_sizes[:, 1]
+
+        self._adjust_pos_cache(tgt_sizes, device=device)
+
+        max_patch_len = torch.max(patch_len)
+        key_padding_mask = torch.zeros((bs, max_patch_len), dtype=torch.bool, device=device)
+
+        pos_embed = []
+        for i in range(bs):
+            tgt_h, tgt_w = tgt_sizes[i]
+            pos_embed.append(self.pos_embed[:tgt_h, :tgt_w, :].reshape((tgt_h * tgt_w, -1)).to(dtype))  # patches * D
+            key_padding_mask[i, patch_len[i]:] = True
+
+        pos_embed = torch.nn.utils.rnn.pad_sequence(
+            pos_embed, batch_first=True, padding_value=0.0).permute(1, 0, 2)  # BLD => L * B * D
+
+        x = self.kv_proj(x)  # B * L * D
+        x = self.ln_kv(x).permute(1, 0, 2)  # L * B * D
+
+        q = self.ln_q(self.query)  # Q * D
+
+        out = self.attn(
+            self._repeat(q, bs),  # Q * B * D
+            x + pos_embed,  # L * B * D +  L * B * D
+            x,
+            key_padding_mask=key_padding_mask)[0]
+        #  out: Q * B * D
+        x = out.permute(1, 0, 2)  # B * Q * D
+
+        x = self.ln_post(x)
+        x = x @ self.proj
+        return x
+
+    def _repeat(self, query, N: int):
+        return query.unsqueeze(1).repeat(1, N, 1)
+
+
+class MultiheadAttention(nn.MultiheadAttention):
+    def __init__(self, embed_dim, num_heads, dropout=0., bias=True, add_bias_kv=False, 
+                 add_zero_attn=False, kdim=None, vdim=None, batch_first=False, device=None, dtype=None):
+        super().__init__(embed_dim, num_heads, dropout, bias, add_bias_kv, add_zero_attn, kdim, vdim, batch_first, device, dtype)
+
+        # rewrite out_proj layer，with nn.Linear
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias, device=device, dtype=dtype)
+
+    def forward(
+                self,
+                query: Tensor,
+                key: Tensor,
+                value: Tensor,
+                key_padding_mask: Optional[Tensor] = None,
+                need_weights: bool = True,
+                attn_mask: Optional[Tensor] = None,
+                average_attn_weights: bool = True,
+                is_causal : bool = False) -> Tuple[Tensor, Optional[Tensor]]:
+        why_not_fast_path = ''
+        if ((attn_mask is not None and torch.is_floating_point(attn_mask))
+           or (key_padding_mask is not None) and torch.is_floating_point(key_padding_mask)):
+            why_not_fast_path = "floating-point masks are not supported for fast path."
+
+        is_batched = query.dim() == 3
+
+        key_padding_mask = F._canonical_mask(
+            mask=key_padding_mask,
+            mask_name="key_padding_mask",
+            other_type=F._none_or_dtype(attn_mask),
+            other_name="attn_mask",
+            target_type=query.dtype
+        )
+
+        attn_mask = F._canonical_mask(
+            mask=attn_mask,
+            mask_name="attn_mask",
+            other_type=None,
+            other_name="",
+            target_type=query.dtype,
+            check_other=False,
+        )
+
+
+        if not is_batched:
+            why_not_fast_path = f"input not batched; expected query.dim() of 3 but got {query.dim()}"
+        elif query is not key or key is not value:
+            # When lifting this restriction, don't forget to either
+            # enforce that the dtypes all match or test cases where
+            # they don't!
+            why_not_fast_path = "non-self attention was used (query, key, and value are not the same Tensor)"
+        elif self.in_proj_bias is not None and query.dtype != self.in_proj_bias.dtype:
+            why_not_fast_path = f"dtypes of query ({query.dtype}) and self.in_proj_bias ({self.in_proj_bias.dtype}) don't match"
+        elif self.in_proj_weight is None:
+            why_not_fast_path = "in_proj_weight was None"
+        elif query.dtype != self.in_proj_weight.dtype:
+            # this case will fail anyway, but at least they'll get a useful error message.
+            why_not_fast_path = f"dtypes of query ({query.dtype}) and self.in_proj_weight ({self.in_proj_weight.dtype}) don't match"
+        elif self.training:
+            why_not_fast_path = "training is enabled"
+        elif (self.num_heads % 2) != 0:
+            why_not_fast_path = "self.num_heads is not even"
+        elif not self.batch_first:
+            why_not_fast_path = "batch_first was not True"
+        elif self.bias_k is not None:
+            why_not_fast_path = "self.bias_k was not None"
+        elif self.bias_v is not None:
+            why_not_fast_path = "self.bias_v was not None"
+        elif self.add_zero_attn:
+            why_not_fast_path = "add_zero_attn was enabled"
+        elif not self._qkv_same_embed_dim:
+            why_not_fast_path = "_qkv_same_embed_dim was not True"
+        elif query.is_nested and (key_padding_mask is not None or attn_mask is not None):
+            why_not_fast_path = "supplying both src_key_padding_mask and src_mask at the same time \
+                                 is not supported with NestedTensor input"
+        elif torch.is_autocast_enabled():
+            why_not_fast_path = "autocast is enabled"
+
+        if not why_not_fast_path:
+            tensor_args = (
+                query,
+                key,
+                value,
+                self.in_proj_weight,
+                self.in_proj_bias,
+                self.out_proj.weight,
+                self.out_proj.bias,
+            )
+            # We have to use list comprehensions below because TorchScript does not support
+            # generator expressions.
+            if torch.overrides.has_torch_function(tensor_args):
+                why_not_fast_path = "some Tensor argument has_torch_function"
+            elif _is_make_fx_tracing():
+                why_not_fast_path = "we are running make_fx tracing"
+            elif not all(_check_arg_device(x) for x in tensor_args):
+                why_not_fast_path = ("some Tensor argument's device is neither one of "
+                                     f"cpu, cuda or {torch.utils.backend_registration._privateuse1_backend_name}")
+            elif torch.is_grad_enabled() and any(_arg_requires_grad(x) for x in tensor_args):
+                why_not_fast_path = ("grad is enabled and at least one of query or the "
+                                     "input/output projection weights or biases requires_grad")
+            if not why_not_fast_path:
+                merged_mask, mask_type = self.merge_masks(attn_mask, key_padding_mask, query)
+
+                if self.in_proj_bias is not None and self.in_proj_weight is not None:
+                    return torch._native_multi_head_attention(
+                        query,
+                        key,
+                        value,
+                        self.embed_dim,
+                        self.num_heads,
+                        self.in_proj_weight,
+                        self.in_proj_bias,
+                        self.out_proj.weight,
+                        self.out_proj.bias,
+                        merged_mask,
+                        need_weights,
+                        average_attn_weights,
+                        mask_type)
+
+        any_nested = query.is_nested or key.is_nested or value.is_nested
+        assert not any_nested, ("MultiheadAttention does not support NestedTensor outside of its fast path. " +
+                                f"The fast path was not hit because {why_not_fast_path}")
+
+        if self.batch_first and is_batched:
+            # make sure that the transpose op does not affect the "is" property
+            if key is value:
+                if query is key:
+                    query = key = value = query.transpose(1, 0)
+                else:
+                    query, key = (x.transpose(1, 0) for x in (query, key))
+                    value = key
+            else:
+                query, key, value = (x.transpose(1, 0) for x in (query, key, value))
+        
+        if not self._qkv_same_embed_dim:
+            attn_output, attn_output_weights = self.multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask, need_weights=need_weights,
+                attn_mask=attn_mask,
+                use_separate_proj_weight=True,
+                q_proj_weight=self.q_proj_weight, k_proj_weight=self.k_proj_weight,
+                v_proj_weight=self.v_proj_weight,
+                average_attn_weights=average_attn_weights,
+                is_causal=is_causal)
+        else:
+            attn_output, attn_output_weights = self.multi_head_attention_forward(
+                query, key, value, self.embed_dim, self.num_heads,
+                self.in_proj_weight, self.in_proj_bias,
+                self.bias_k, self.bias_v, self.add_zero_attn,
+                self.dropout, self.out_proj.weight, self.out_proj.bias,
+                training=self.training,
+                key_padding_mask=key_padding_mask,
+                need_weights=need_weights,
+                attn_mask=attn_mask,
+                average_attn_weights=average_attn_weights,
+                is_causal=is_causal)
+        if self.batch_first and is_batched:
+            return attn_output.transpose(1, 0), attn_output_weights
+        else:
+            return attn_output, attn_output_weights
+            
+    def multi_head_attention_forward(
+        self,
+        query: Tensor,
+        key: Tensor,
+        value: Tensor,
+        embed_dim_to_check: int,
+        num_heads: int,
+        in_proj_weight: Optional[Tensor],
+        in_proj_bias: Optional[Tensor],
+        bias_k: Optional[Tensor],
+        bias_v: Optional[Tensor],
+        add_zero_attn: bool,
+        dropout_p: float,
+        out_proj_weight: Tensor,
+        out_proj_bias: Optional[Tensor],
+        training: bool = True,
+        key_padding_mask: Optional[Tensor] = None,
+        need_weights: bool = True,
+        attn_mask: Optional[Tensor] = None,
+        use_separate_proj_weight: bool = False,
+        q_proj_weight: Optional[Tensor] = None,
+        k_proj_weight: Optional[Tensor] = None,
+        v_proj_weight: Optional[Tensor] = None,
+        static_k: Optional[Tensor] = None,
+        static_v: Optional[Tensor] = None,
+        average_attn_weights: bool = True,
+        is_causal: bool = False,
+    ) -> Tuple[Tensor, Optional[Tensor]]:
+        tens_ops = (query, key, value, in_proj_weight, in_proj_bias, bias_k, bias_v, out_proj_weight, out_proj_bias)
+        if has_torch_function(tens_ops):
+            return handle_torch_function(
+                multi_head_attention_forward,
+                tens_ops,
+                query,
+                key,
+                value,
+                embed_dim_to_check,
+                num_heads,
+                in_proj_weight,
+                in_proj_bias,
+                bias_k,
+                bias_v,
+                add_zero_attn,
+                dropout_p,
+                out_proj_weight,
+                out_proj_bias,
+                training=training,
+                key_padding_mask=key_padding_mask,
+                need_weights=need_weights,
+                attn_mask=attn_mask,
+                is_causal=is_causal,
+                use_separate_proj_weight=use_separate_proj_weight,
+                q_proj_weight=q_proj_weight,
+                k_proj_weight=k_proj_weight,
+                v_proj_weight=v_proj_weight,
+                static_k=static_k,
+                static_v=static_v,
+                average_attn_weights=average_attn_weights,
+            )
+    
+        is_batched = _mha_shape_check(query, key, value, key_padding_mask, attn_mask, num_heads)
+    
+        # For unbatched input, we unsqueeze at the expected batch-dim to pretend that the input
+        # is batched, run the computation and before returning squeeze the
+        # batch dimension so that the output doesn't carry this temporary batch dimension.
+        if not is_batched:
+            # unsqueeze if the input is unbatched
+            query = query.unsqueeze(1)
+            key = key.unsqueeze(1)
+            value = value.unsqueeze(1)
+            if key_padding_mask is not None:
+                key_padding_mask = key_padding_mask.unsqueeze(0)
+    
+        # set up shape vars
+        tgt_len, bsz, embed_dim = query.shape
+        src_len, _, _ = key.shape
+    
+        key_padding_mask = _canonical_mask(
+            mask=key_padding_mask,
+            mask_name="key_padding_mask",
+            other_type=_none_or_dtype(attn_mask),
+            other_name="attn_mask",
+            target_type=query.dtype
+        )
+    
+        if is_causal and attn_mask is None:
+            raise RuntimeError(
+                "Need attn_mask if specifying the is_causal hint. "
+                "You may use the Transformer module method "
+                "`generate_square_subsequent_mask` to create this mask."
+            )
+    
+        if is_causal and key_padding_mask is None and not need_weights:
+            # when we have a kpm or need weights, we need attn_mask
+            # Otherwise, we use the is_causal hint go as is_causal
+            # indicator to SDPA.
+            attn_mask = None
+        else:
+            attn_mask = _canonical_mask(
+                mask=attn_mask,
+                mask_name="attn_mask",
+                other_type=None,
+                other_name="",
+                target_type=query.dtype,
+                check_other=False,
+            )
+    
+            if key_padding_mask is not None:
+                # We have the attn_mask, and use that to merge kpm into it.
+                # Turn off use of is_causal hint, as the merged mask is no
+                # longer causal.
+                is_causal = False
+    
+        assert embed_dim == embed_dim_to_check, \
+            f"was expecting embedding dimension of {embed_dim_to_check}, but got {embed_dim}"
+        if isinstance(embed_dim, torch.Tensor):
+            # embed_dim can be a tensor when JIT tracing
+            head_dim = embed_dim.div(num_heads, rounding_mode='trunc')
+        else:
+            head_dim = embed_dim // num_heads
+        assert head_dim * num_heads == embed_dim, f"embed_dim {embed_dim} not divisible by num_heads {num_heads}"
+        if use_separate_proj_weight:
+            # allow MHA to have different embedding dimensions when separate projection weights are used
+            assert key.shape[:2] == value.shape[:2], \
+                f"key's sequence and batch dims {key.shape[:2]} do not match value's {value.shape[:2]}"
+        else:
+            assert key.shape == value.shape, f"key shape {key.shape} does not match value shape {value.shape}"
+    
+        #
+        # compute in-projection
+        #
+        if not use_separate_proj_weight:
+            assert in_proj_weight is not None, "use_separate_proj_weight is False but in_proj_weight is None"
+            q, k, v = _in_projection_packed(query, key, value, in_proj_weight, in_proj_bias)
+        else:
+            assert q_proj_weight is not None, "use_separate_proj_weight is True but q_proj_weight is None"
+            assert k_proj_weight is not None, "use_separate_proj_weight is True but k_proj_weight is None"
+            assert v_proj_weight is not None, "use_separate_proj_weight is True but v_proj_weight is None"
+            if in_proj_bias is None:
+                b_q = b_k = b_v = None
+            else:
+                b_q, b_k, b_v = in_proj_bias.chunk(3)
+            q, k, v = _in_projection(query, key, value, q_proj_weight, k_proj_weight, v_proj_weight, b_q, b_k, b_v)
+    
+        # prep attention mask
+    
+        if attn_mask is not None:
+            # ensure attn_mask's dim is 3
+            if attn_mask.dim() == 2:
+                correct_2d_size = (tgt_len, src_len)
+                if attn_mask.shape != correct_2d_size:
+                    raise RuntimeError(f"The shape of the 2D attn_mask is {attn_mask.shape}, but should be {correct_2d_size}.")
+                attn_mask = attn_mask.unsqueeze(0)
+            elif attn_mask.dim() == 3:
+                correct_3d_size = (bsz * num_heads, tgt_len, src_len)
+                if attn_mask.shape != correct_3d_size:
+                    raise RuntimeError(f"The shape of the 3D attn_mask is {attn_mask.shape}, but should be {correct_3d_size}.")
+            else:
+                raise RuntimeError(f"attn_mask's dimension {attn_mask.dim()} is not supported")
+    
+        # add bias along batch dimension (currently second)
+        if bias_k is not None and bias_v is not None:
+            assert static_k is None, "bias cannot be added to static key."
+            assert static_v is None, "bias cannot be added to static value."
+            k = torch.cat([k, bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = pad(attn_mask, (0, 1))
+            if key_padding_mask is not None:
+                key_padding_mask = pad(key_padding_mask, (0, 1))
+        else:
+            assert bias_k is None
+            assert bias_v is None
+    
+        #
+        # reshape q, k, v for multihead attention and make em batch first
+        #
+        q = q.view(tgt_len, bsz * num_heads, head_dim).transpose(0, 1)
+        if static_k is None:
+            k = k.view(k.shape[0], bsz * num_heads, head_dim).transpose(0, 1)
+        else:
+            # TODO finish disentangling control flow so we don't do in-projections when statics are passed
+            assert static_k.size(0) == bsz * num_heads, \
+                f"expecting static_k.size(0) of {bsz * num_heads}, but got {static_k.size(0)}"
+            assert static_k.size(2) == head_dim, \
+                f"expecting static_k.size(2) of {head_dim}, but got {static_k.size(2)}"
+            k = static_k
+        if static_v is None:
+            v = v.view(v.shape[0], bsz * num_heads, head_dim).transpose(0, 1)
+        else:
+            # TODO finish disentangling control flow so we don't do in-projections when statics are passed
+            assert static_v.size(0) == bsz * num_heads, \
+                f"expecting static_v.size(0) of {bsz * num_heads}, but got {static_v.size(0)}"
+            assert static_v.size(2) == head_dim, \
+                f"expecting static_v.size(2) of {head_dim}, but got {static_v.size(2)}"
+            v = static_v
+    
+        # add zero attention along batch dimension (now first)
+        if add_zero_attn:
+            zero_attn_shape = (bsz * num_heads, 1, head_dim)
+            k = torch.cat([k, torch.zeros(zero_attn_shape, dtype=k.dtype, device=k.device)], dim=1)
+            v = torch.cat([v, torch.zeros(zero_attn_shape, dtype=v.dtype, device=v.device)], dim=1)
+            if attn_mask is not None:
+                attn_mask = pad(attn_mask, (0, 1))
+            if key_padding_mask is not None:
+                key_padding_mask = pad(key_padding_mask, (0, 1))
+    
+        # update source sequence length after adjustments
+        src_len = k.size(1)
+    
+        # merge key padding and attention masks
+        if key_padding_mask is not None:
+            assert key_padding_mask.shape == (bsz, src_len), \
+                f"expecting key_padding_mask shape of {(bsz, src_len)}, but got {key_padding_mask.shape}"
+            key_padding_mask = key_padding_mask.view(bsz, 1, 1, src_len).   \
+                expand(-1, num_heads, -1, -1).reshape(bsz * num_heads, 1, src_len)
+            if attn_mask is None:
+                attn_mask = key_padding_mask
+            else:
+                attn_mask = attn_mask + key_padding_mask
+    
+        # adjust dropout probability
+        if not training:
+            dropout_p = 0.0
+    
+        #
+        # (deep breath) calculate attention and out projection
+        #
+    
+        if need_weights:
+            B, Nt, E = q.shape
+            q_scaled = q / math.sqrt(E)
+    
+            assert not (is_causal and attn_mask is None), "FIXME: is_causal not implemented for need_weights"
+    
+            if attn_mask is not None:
+                attn_output_weights = torch.baddbmm(attn_mask, q_scaled, k.transpose(-2, -1))
+            else:
+                attn_output_weights = torch.bmm(q_scaled, k.transpose(-2, -1))
+            attn_output_weights = softmax(attn_output_weights, dim=-1)
+            if dropout_p > 0.0:
+                attn_output_weights = dropout(attn_output_weights, p=dropout_p)
+    
+            attn_output = torch.bmm(attn_output_weights, v)
+    
+            attn_output = attn_output.transpose(0, 1).contiguous().view(tgt_len * bsz, embed_dim)
+            attn_output = self.out_proj(attn_output)
+            attn_output = attn_output.view(tgt_len, bsz, attn_output.size(1))
+    
+            # optionally average attention weights over heads
+            attn_output_weights = attn_output_weights.view(bsz, num_heads, tgt_len, src_len)
+            if average_attn_weights:
+                attn_output_weights = attn_output_weights.mean(dim=1)
+    
+            if not is_batched:
+                # squeeze the output if input was unbatched
+                attn_output = attn_output.squeeze(1)
+                attn_output_weights = attn_output_weights.squeeze(0)
+            return attn_output, attn_output_weights
+        else:
+            # attn_mask can be either (L,S) or (N*num_heads, L, S)
+            # if attn_mask's shape is (1, L, S) we need to unsqueeze to (1, 1, L, S)
+            # in order to match the input for SDPA of (N, num_heads, L, S)
+            if attn_mask is not None:
+                if attn_mask.size(0) == 1 and attn_mask.dim() == 3:
+                    attn_mask = attn_mask.unsqueeze(0)
+                else:
+                    attn_mask = attn_mask.view(bsz, num_heads, -1, src_len)
+    
+            q = q.view(bsz, num_heads, tgt_len, head_dim)
+            k = k.view(bsz, num_heads, src_len, head_dim)
+            v = v.view(bsz, num_heads, src_len, head_dim)
+    
+            attn_output = F.scaled_dot_product_attention(q, k, v, attn_mask, dropout_p, is_causal)
+            attn_output = attn_output.permute(2, 0, 1, 3).contiguous().view(bsz * tgt_len, embed_dim)
+    
+            attn_output = self.out_proj(attn_output)
+            attn_output = attn_output.view(tgt_len, bsz, attn_output.size(1))
+            if not is_batched:
+                # squeeze the output if input was unbatched
+                attn_output = attn_output.squeeze(1)
+            return attn_output, None
+
+
+def _mha_shape_check(query: Tensor, key: Tensor, value: Tensor,
+                     key_padding_mask: Optional[Tensor], attn_mask: Optional[Tensor], num_heads: int):
+    # Verifies the expected shape for `query, `key`, `value`, `key_padding_mask` and `attn_mask`
+    # and returns if the input is batched or not.
+    # Raises an error if `query` is not 2-D (unbatched) or 3-D (batched) tensor.
+
+    # Shape check.
+    if query.dim() == 3:
+        # Batched Inputs
+        is_batched = True
+        assert key.dim() == 3 and value.dim() == 3, \
+            ("For batched (3-D) `query`, expected `key` and `value` to be 3-D"
+             f" but found {key.dim()}-D and {value.dim()}-D tensors respectively")
+        if key_padding_mask is not None:
+            assert key_padding_mask.dim() == 2, \
+                ("For batched (3-D) `query`, expected `key_padding_mask` to be `None` or 2-D"
+                 f" but found {key_padding_mask.dim()}-D tensor instead")
+        if attn_mask is not None:
+            assert attn_mask.dim() in (2, 3), \
+                ("For batched (3-D) `query`, expected `attn_mask` to be `None`, 2-D or 3-D"
+                 f" but found {attn_mask.dim()}-D tensor instead")
+    elif query.dim() == 2:
+        # Unbatched Inputs
+        is_batched = False
+        assert key.dim() == 2 and value.dim() == 2, \
+            ("For unbatched (2-D) `query`, expected `key` and `value` to be 2-D"
+             f" but found {key.dim()}-D and {value.dim()}-D tensors respectively")
+
+        if key_padding_mask is not None:
+            assert key_padding_mask.dim() == 1, \
+                ("For unbatched (2-D) `query`, expected `key_padding_mask` to be `None` or 1-D"
+                 f" but found {key_padding_mask.dim()}-D tensor instead")
+
+        if attn_mask is not None:
+            assert attn_mask.dim() in (2, 3), \
+                ("For unbatched (2-D) `query`, expected `attn_mask` to be `None`, 2-D or 3-D"
+                 f" but found {attn_mask.dim()}-D tensor instead")
+            if attn_mask.dim() == 3:
+                expected_shape = (num_heads, query.shape[0], key.shape[0])
+                assert attn_mask.shape == expected_shape, \
+                    (f"Expected `attn_mask` shape to be {expected_shape} but got {attn_mask.shape}")
+    else:
+        raise AssertionError(
+            f"query should be unbatched 2D or batched 3D tensor but received {query.dim()}-D query tensor")
+
+    return is_batched
+
+
+def _canonical_mask(
+        mask: Optional[Tensor],
+        mask_name: str,
+        other_type: Optional[DType],
+        other_name: str,
+        target_type: DType,
+        check_other: bool = True,
+) -> Optional[Tensor]:
+
+    if mask is not None:
+        _mask_dtype = mask.dtype
+        _mask_is_float = torch.is_floating_point(mask)
+        if _mask_dtype != torch.bool and not _mask_is_float:
+            raise AssertionError(
+                f"only bool and floating types of {mask_name} are supported")
+        if check_other and other_type is not None:
+            if _mask_dtype != other_type:
+                warnings.warn(
+                    f"Support for mismatched {mask_name} and {other_name} "
+                    "is deprecated. Use same type for both instead."
+                )
+        if not _mask_is_float:
+            mask = (
+                torch.zeros_like(mask, dtype=target_type)
+                .masked_fill_(mask, float("-inf"))
+            )
+    return mask
+
+
+def _none_or_dtype(input: Optional[Tensor]) -> Optional[DType]:
+    if input is None:
+        return None
+    elif isinstance(input, torch.Tensor):
+        return input.dtype
+    raise RuntimeError("input to _none_or_dtype() must be None or torch.Tensor")
+
+def _in_projection_packed(
+    q: Tensor,
+    k: Tensor,
+    v: Tensor,
+    w: Tensor,
+    b: Optional[Tensor] = None,
+) -> List[Tensor]:
+    r"""
+    Performs the in-projection step of the attention operation, using packed weights.
+    Output is a triple containing projection tensors for query, key and value.
+    Args:
+        q, k, v: query, key and value tensors to be projected. For self-attention,
+            these are typically the same tensor; for encoder-decoder attention,
+            k and v are typically the same tensor. (We take advantage of these
+            identities for performance if they are present.) Regardless, q, k and v
+            must share a common embedding dimension; otherwise their shapes may vary.
+        w: projection weights for q, k and v, packed into a single tensor. Weights
+            are packed along dimension 0, in q, k, v order.
+        b: optional projection biases for q, k and v, packed into a single tensor
+            in q, k, v order.
+    Shape:
+        Inputs:
+        - q: :math:`(..., E)` where E is the embedding dimension
+        - k: :math:`(..., E)` where E is the embedding dimension
+        - v: :math:`(..., E)` where E is the embedding dimension
+        - w: :math:`(E * 3, E)` where E is the embedding dimension
+        - b: :math:`E * 3` where E is the embedding dimension
+        Output:
+        - in output list :math:`[q', k', v']`, each output tensor will have the
+            same shape as the corresponding input tensor.
+    """
+    E = q.size(-1)
+    if k is v:
+        if q is k:
+            # self-attention
+            proj = linear(q, w, b)
+            # reshape to 3, E and not E, 3 is deliberate for better memory coalescing and keeping same order as chunk()
+            proj = proj.unflatten(-1, (3, E)).unsqueeze(0).transpose(0, -2).squeeze(-2).contiguous()
+            return proj[0], proj[1], proj[2]
+        else:
+            # encoder-decoder attention
+            w_q, w_kv = w.split([E, E * 2])
+            if b is None:
+                b_q = b_kv = None
+            else:
+                b_q, b_kv = b.split([E, E * 2])
+            q_proj = linear(q, w_q, b_q)
+            kv_proj = linear(k, w_kv, b_kv)
+            # reshape to 2, E and not E, 2 is deliberate for better memory coalescing and keeping same order as chunk()
+            kv_proj = kv_proj.unflatten(-1, (2, E)).unsqueeze(0).transpose(0, -2).squeeze(-2).contiguous()
+            return (q_proj, kv_proj[0], kv_proj[1])
+    else:
+        w_q, w_k, w_v = w.chunk(3)
+        if b is None:
+            b_q = b_k = b_v = None
+        else:
+            b_q, b_k, b_v = b.chunk(3)
+        return linear(q, w_q, b_q), linear(k, w_k, b_k), linear(v, w_v, b_v)
+
+
+def _in_projection(
+    q: Tensor,
+    k: Tensor,
+    v: Tensor,
+    w_q: Tensor,
+    w_k: Tensor,
+    w_v: Tensor,
+    b_q: Optional[Tensor] = None,
+    b_k: Optional[Tensor] = None,
+    b_v: Optional[Tensor] = None,
+) -> Tuple[Tensor, Tensor, Tensor]:
+    r"""
+    Performs the in-projection step of the attention operation. This is simply
+    a triple of linear projections, with shape constraints on the weights which
+    ensure embedding dimension uniformity in the projected outputs.
+    Output is a triple containing projection tensors for query, key and value.
+    Args:
+        q, k, v: query, key and value tensors to be projected.
+        w_q, w_k, w_v: weights for q, k and v, respectively.
+        b_q, b_k, b_v: optional biases for q, k and v, respectively.
+    Shape:
+        Inputs:
+        - q: :math:`(Qdims..., Eq)` where Eq is the query embedding dimension and Qdims are any
+            number of leading dimensions.
+        - k: :math:`(Kdims..., Ek)` where Ek is the key embedding dimension and Kdims are any
+            number of leading dimensions.
+        - v: :math:`(Vdims..., Ev)` where Ev is the value embedding dimension and Vdims are any
+            number of leading dimensions.
+        - w_q: :math:`(Eq, Eq)`
+        - w_k: :math:`(Eq, Ek)`
+        - w_v: :math:`(Eq, Ev)`
+        - b_q: :math:`(Eq)`
+        - b_k: :math:`(Eq)`
+        - b_v: :math:`(Eq)`
+        Output: in output triple :math:`(q', k', v')`,
+         - q': :math:`[Qdims..., Eq]`
+         - k': :math:`[Kdims..., Eq]`
+         - v': :math:`[Vdims..., Eq]`
+    """
+    Eq, Ek, Ev = q.size(-1), k.size(-1), v.size(-1)
+    assert w_q.shape == (Eq, Eq), f"expecting query weights shape of {(Eq, Eq)}, but got {w_q.shape}"
+    assert w_k.shape == (Eq, Ek), f"expecting key weights shape of {(Eq, Ek)}, but got {w_k.shape}"
+    assert w_v.shape == (Eq, Ev), f"expecting value weights shape of {(Eq, Ev)}, but got {w_v.shape}"
+    assert b_q is None or b_q.shape == (Eq,), f"expecting query bias shape of {(Eq,)}, but got {b_q.shape}"
+    assert b_k is None or b_k.shape == (Eq,), f"expecting key bias shape of {(Eq,)}, but got {b_k.shape}"
+    assert b_v is None or b_v.shape == (Eq,), f"expecting value bias shape of {(Eq,)}, but got {b_v.shape}"
+    return linear(q, w_q, b_q), linear(k, w_k, b_k), linear(v, w_v, b_v)

special_tokens_map.json

@@ -0,0 +1,24 @@
+{
+  "bos_token": {
+    "content": "<|begin_of_text|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|end_of_text|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": "!",
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenization_minicpmv_fast.py

@@ -0,0 +1,51 @@
+import json
+
+from transformers.tokenization_utils_fast import PreTrainedTokenizerFast
+
+
+class MiniCPMVTokenizerFast(PreTrainedTokenizerFast):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.eot_token = "<|eot_id|>"
+        self.im_start = "<image>"
+        self.im_end = "</image>"
+        self.ref_start = "<ref>"
+        self.ref_end = "</ref>"
+        self.box_start = "<box>"
+        self.box_end = "</box>"
+        self.quad_start = "<quad>"
+        self.quad_end = "</quad>"
+        self.slice_start = "<slice>"
+        self.slice_end = "</slice>"
+
+    @property
+    def eos_id(self):
+        return self.eos_token_id
+
+    @property
+    def bos_id(self):
+        return self.bos_token_id
+
+    @property
+    def unk_id(self):
+        return self.unk_token_id
+
+    @property
+    def eot_id(self):
+        return self.convert_tokens_to_ids(self.eot_token)
+
+    @property
+    def im_start_id(self):
+        return self.convert_tokens_to_ids(self.im_start)
+
+    @property
+    def im_end_id(self):
+        return self.convert_tokens_to_ids(self.im_end)
+
+    @staticmethod
+    def escape(text: str) -> str:
+        return text
+
+    @staticmethod
+    def unescape(text: str) -> str:
+        return text

tokenizer_config.json

@@ -0,0 +1,2072 @@
+{
+  "added_tokens_decoder": {
+    "128000": {
+      "content": "<|begin_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128001": {
+      "content": "<|end_of_text|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128002": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128003": {
+      "content": "<|reserved_special_token_1|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128004": {
+      "content": "<|reserved_special_token_2|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128005": {
+      "content": "<|reserved_special_token_3|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128006": {
+      "content": "<|start_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128007": {
+      "content": "<|end_header_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128008": {
+      "content": "<|reserved_special_token_4|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128009": {
+      "content": "<|eot_id|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128010": {
+      "content": "<image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128011": {
+      "content": "</image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128012": {
+      "content": "<ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128013": {
+      "content": "</ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128014": {
+      "content": "<box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128015": {
+      "content": "</box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128016": {
+      "content": "<quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128017": {
+      "content": "</quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128018": {
+      "content": "<point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128019": {
+      "content": "</point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128020": {
+      "content": "<slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128021": {
+      "content": "</slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128022": {
+      "content": "<|reserved_special_token_17|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128023": {
+      "content": "<|reserved_special_token_18|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128024": {
+      "content": "<|reserved_special_token_19|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128025": {
+      "content": "<|reserved_special_token_20|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128026": {
+      "content": "<|reserved_special_token_21|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128027": {
+      "content": "<|reserved_special_token_22|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128028": {
+      "content": "<|reserved_special_token_23|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128029": {
+      "content": "<|reserved_special_token_24|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128030": {
+      "content": "<|reserved_special_token_25|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128031": {
+      "content": "<|reserved_special_token_26|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128032": {
+      "content": "<|reserved_special_token_27|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128033": {
+      "content": "<|reserved_special_token_28|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128034": {
+      "content": "<|reserved_special_token_29|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128035": {
+      "content": "<|reserved_special_token_30|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128036": {
+      "content": "<|reserved_special_token_31|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128037": {
+      "content": "<|reserved_special_token_32|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128038": {
+      "content": "<|reserved_special_token_33|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128039": {
+      "content": "<|reserved_special_token_34|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128040": {
+      "content": "<|reserved_special_token_35|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128041": {
+      "content": "<|reserved_special_token_36|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128042": {
+      "content": "<|reserved_special_token_37|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128043": {
+      "content": "<|reserved_special_token_38|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128044": {
+      "content": "<|reserved_special_token_39|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128045": {
+      "content": "<|reserved_special_token_40|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128046": {
+      "content": "<|reserved_special_token_41|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128047": {
+      "content": "<|reserved_special_token_42|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128048": {
+      "content": "<|reserved_special_token_43|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128049": {
+      "content": "<|reserved_special_token_44|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128050": {
+      "content": "<|reserved_special_token_45|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128051": {
+      "content": "<|reserved_special_token_46|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128052": {
+      "content": "<|reserved_special_token_47|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128053": {
+      "content": "<|reserved_special_token_48|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128054": {
+      "content": "<|reserved_special_token_49|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128055": {
+      "content": "<|reserved_special_token_50|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128056": {
+      "content": "<|reserved_special_token_51|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128057": {
+      "content": "<|reserved_special_token_52|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128058": {
+      "content": "<|reserved_special_token_53|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128059": {
+      "content": "<|reserved_special_token_54|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128060": {
+      "content": "<|reserved_special_token_55|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128061": {
+      "content": "<|reserved_special_token_56|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128062": {
+      "content": "<|reserved_special_token_57|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128063": {
+      "content": "<|reserved_special_token_58|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128064": {
+      "content": "<|reserved_special_token_59|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128065": {
+      "content": "<|reserved_special_token_60|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128066": {
+      "content": "<|reserved_special_token_61|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128067": {
+      "content": "<|reserved_special_token_62|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128068": {
+      "content": "<|reserved_special_token_63|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128069": {
+      "content": "<|reserved_special_token_64|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128070": {
+      "content": "<|reserved_special_token_65|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128071": {
+      "content": "<|reserved_special_token_66|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128072": {
+      "content": "<|reserved_special_token_67|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128073": {
+      "content": "<|reserved_special_token_68|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128074": {
+      "content": "<|reserved_special_token_69|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128075": {
+      "content": "<|reserved_special_token_70|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128076": {
+      "content": "<|reserved_special_token_71|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128077": {
+      "content": "<|reserved_special_token_72|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128078": {
+      "content": "<|reserved_special_token_73|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128079": {
+      "content": "<|reserved_special_token_74|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128080": {
+      "content": "<|reserved_special_token_75|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128081": {
+      "content": "<|reserved_special_token_76|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128082": {
+      "content": "<|reserved_special_token_77|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128083": {
+      "content": "<|reserved_special_token_78|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128084": {
+      "content": "<|reserved_special_token_79|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128085": {
+      "content": "<|reserved_special_token_80|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128086": {
+      "content": "<|reserved_special_token_81|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128087": {
+      "content": "<|reserved_special_token_82|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128088": {
+      "content": "<|reserved_special_token_83|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128089": {
+      "content": "<|reserved_special_token_84|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128090": {
+      "content": "<|reserved_special_token_85|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128091": {
+      "content": "<|reserved_special_token_86|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128092": {
+      "content": "<|reserved_special_token_87|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128093": {
+      "content": "<|reserved_special_token_88|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128094": {
+      "content": "<|reserved_special_token_89|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128095": {
+      "content": "<|reserved_special_token_90|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128096": {
+      "content": "<|reserved_special_token_91|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128097": {
+      "content": "<|reserved_special_token_92|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128098": {
+      "content": "<|reserved_special_token_93|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128099": {
+      "content": "<|reserved_special_token_94|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128100": {
+      "content": "<|reserved_special_token_95|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128101": {
+      "content": "<|reserved_special_token_96|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128102": {
+      "content": "<|reserved_special_token_97|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128103": {
+      "content": "<|reserved_special_token_98|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128104": {
+      "content": "<|reserved_special_token_99|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128105": {
+      "content": "<|reserved_special_token_100|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128106": {
+      "content": "<|reserved_special_token_101|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128107": {
+      "content": "<|reserved_special_token_102|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128108": {
+      "content": "<|reserved_special_token_103|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128109": {
+      "content": "<|reserved_special_token_104|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128110": {
+      "content": "<|reserved_special_token_105|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128111": {
+      "content": "<|reserved_special_token_106|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128112": {
+      "content": "<|reserved_special_token_107|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128113": {
+      "content": "<|reserved_special_token_108|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128114": {
+      "content": "<|reserved_special_token_109|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128115": {
+      "content": "<|reserved_special_token_110|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128116": {
+      "content": "<|reserved_special_token_111|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128117": {
+      "content": "<|reserved_special_token_112|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128118": {
+      "content": "<|reserved_special_token_113|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128119": {
+      "content": "<|reserved_special_token_114|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128120": {
+      "content": "<|reserved_special_token_115|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128121": {
+      "content": "<|reserved_special_token_116|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128122": {
+      "content": "<|reserved_special_token_117|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128123": {
+      "content": "<|reserved_special_token_118|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128124": {
+      "content": "<|reserved_special_token_119|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128125": {
+      "content": "<|reserved_special_token_120|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128126": {
+      "content": "<|reserved_special_token_121|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128127": {
+      "content": "<|reserved_special_token_122|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128128": {
+      "content": "<|reserved_special_token_123|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128129": {
+      "content": "<|reserved_special_token_124|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128130": {
+      "content": "<|reserved_special_token_125|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128131": {
+      "content": "<|reserved_special_token_126|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128132": {
+      "content": "<|reserved_special_token_127|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128133": {
+      "content": "<|reserved_special_token_128|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128134": {
+      "content": "<|reserved_special_token_129|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128135": {
+      "content": "<|reserved_special_token_130|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128136": {
+      "content": "<|reserved_special_token_131|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128137": {
+      "content": "<|reserved_special_token_132|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128138": {
+      "content": "<|reserved_special_token_133|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128139": {
+      "content": "<|reserved_special_token_134|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128140": {
+      "content": "<|reserved_special_token_135|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128141": {
+      "content": "<|reserved_special_token_136|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128142": {
+      "content": "<|reserved_special_token_137|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128143": {
+      "content": "<|reserved_special_token_138|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128144": {
+      "content": "<|reserved_special_token_139|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128145": {
+      "content": "<|reserved_special_token_140|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128146": {
+      "content": "<|reserved_special_token_141|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128147": {
+      "content": "<|reserved_special_token_142|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128148": {
+      "content": "<|reserved_special_token_143|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128149": {
+      "content": "<|reserved_special_token_144|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128150": {
+      "content": "<|reserved_special_token_145|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128151": {
+      "content": "<|reserved_special_token_146|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128152": {
+      "content": "<|reserved_special_token_147|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128153": {
+      "content": "<|reserved_special_token_148|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128154": {
+      "content": "<|reserved_special_token_149|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128155": {
+      "content": "<|reserved_special_token_150|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128156": {
+      "content": "<|reserved_special_token_151|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128157": {
+      "content": "<|reserved_special_token_152|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128158": {
+      "content": "<|reserved_special_token_153|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128159": {
+      "content": "<|reserved_special_token_154|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128160": {
+      "content": "<|reserved_special_token_155|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128161": {
+      "content": "<|reserved_special_token_156|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128162": {
+      "content": "<|reserved_special_token_157|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128163": {
+      "content": "<|reserved_special_token_158|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128164": {
+      "content": "<|reserved_special_token_159|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128165": {
+      "content": "<|reserved_special_token_160|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128166": {
+      "content": "<|reserved_special_token_161|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128167": {
+      "content": "<|reserved_special_token_162|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128168": {
+      "content": "<|reserved_special_token_163|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128169": {
+      "content": "<|reserved_special_token_164|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128170": {
+      "content": "<|reserved_special_token_165|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128171": {
+      "content": "<|reserved_special_token_166|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128172": {
+      "content": "<|reserved_special_token_167|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128173": {
+      "content": "<|reserved_special_token_168|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128174": {
+      "content": "<|reserved_special_token_169|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128175": {
+      "content": "<|reserved_special_token_170|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128176": {
+      "content": "<|reserved_special_token_171|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128177": {
+      "content": "<|reserved_special_token_172|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128178": {
+      "content": "<|reserved_special_token_173|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128179": {
+      "content": "<|reserved_special_token_174|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128180": {
+      "content": "<|reserved_special_token_175|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128181": {
+      "content": "<|reserved_special_token_176|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128182": {
+      "content": "<|reserved_special_token_177|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128183": {
+      "content": "<|reserved_special_token_178|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128184": {
+      "content": "<|reserved_special_token_179|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128185": {
+      "content": "<|reserved_special_token_180|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128186": {
+      "content": "<|reserved_special_token_181|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128187": {
+      "content": "<|reserved_special_token_182|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128188": {
+      "content": "<|reserved_special_token_183|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128189": {
+      "content": "<|reserved_special_token_184|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128190": {
+      "content": "<|reserved_special_token_185|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128191": {
+      "content": "<|reserved_special_token_186|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128192": {
+      "content": "<|reserved_special_token_187|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128193": {
+      "content": "<|reserved_special_token_188|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128194": {
+      "content": "<|reserved_special_token_189|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128195": {
+      "content": "<|reserved_special_token_190|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128196": {
+      "content": "<|reserved_special_token_191|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128197": {
+      "content": "<|reserved_special_token_192|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128198": {
+      "content": "<|reserved_special_token_193|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128199": {
+      "content": "<|reserved_special_token_194|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128200": {
+      "content": "<|reserved_special_token_195|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128201": {
+      "content": "<|reserved_special_token_196|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128202": {
+      "content": "<|reserved_special_token_197|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128203": {
+      "content": "<|reserved_special_token_198|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128204": {
+      "content": "<|reserved_special_token_199|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128205": {
+      "content": "<|reserved_special_token_200|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128206": {
+      "content": "<|reserved_special_token_201|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128207": {
+      "content": "<|reserved_special_token_202|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128208": {
+      "content": "<|reserved_special_token_203|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128209": {
+      "content": "<|reserved_special_token_204|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128210": {
+      "content": "<|reserved_special_token_205|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128211": {
+      "content": "<|reserved_special_token_206|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128212": {
+      "content": "<|reserved_special_token_207|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128213": {
+      "content": "<|reserved_special_token_208|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128214": {
+      "content": "<|reserved_special_token_209|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128215": {
+      "content": "<|reserved_special_token_210|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128216": {
+      "content": "<|reserved_special_token_211|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128217": {
+      "content": "<|reserved_special_token_212|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128218": {
+      "content": "<|reserved_special_token_213|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128219": {
+      "content": "<|reserved_special_token_214|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128220": {
+      "content": "<|reserved_special_token_215|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128221": {
+      "content": "<|reserved_special_token_216|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128222": {
+      "content": "<|reserved_special_token_217|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128223": {
+      "content": "<|reserved_special_token_218|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128224": {
+      "content": "<|reserved_special_token_219|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128225": {
+      "content": "<|reserved_special_token_220|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128226": {
+      "content": "<|reserved_special_token_221|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128227": {
+      "content": "<|reserved_special_token_222|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128228": {
+      "content": "<|reserved_special_token_223|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128229": {
+      "content": "<|reserved_special_token_224|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128230": {
+      "content": "<|reserved_special_token_225|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128231": {
+      "content": "<|reserved_special_token_226|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128232": {
+      "content": "<|reserved_special_token_227|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128233": {
+      "content": "<|reserved_special_token_228|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128234": {
+      "content": "<|reserved_special_token_229|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128235": {
+      "content": "<|reserved_special_token_230|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128236": {
+      "content": "<|reserved_special_token_231|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128237": {
+      "content": "<|reserved_special_token_232|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128238": {
+      "content": "<|reserved_special_token_233|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128239": {
+      "content": "<|reserved_special_token_234|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128240": {
+      "content": "<|reserved_special_token_235|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128241": {
+      "content": "<|reserved_special_token_236|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128242": {
+      "content": "<|reserved_special_token_237|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128243": {
+      "content": "<|reserved_special_token_238|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128244": {
+      "content": "<|reserved_special_token_239|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128245": {
+      "content": "<|reserved_special_token_240|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128246": {
+      "content": "<|reserved_special_token_241|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128247": {
+      "content": "<|reserved_special_token_242|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128248": {
+      "content": "<|reserved_special_token_243|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128249": {
+      "content": "<|reserved_special_token_244|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128250": {
+      "content": "<|reserved_special_token_245|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128251": {
+      "content": "<|reserved_special_token_246|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128252": {
+      "content": "<|reserved_special_token_247|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128253": {
+      "content": "<|reserved_special_token_248|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128254": {
+      "content": "<|reserved_special_token_249|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128255": {
+      "content": "<|reserved_special_token_250|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_minicpmv_fast.MiniCPMVTokenizerFast",
+      null
+    ]
+  },
+  "bos_token": "<|begin_of_text|>",
+  "chat_template": "{% set loop_messages = messages %}{% for message in loop_messages %}{% set content = '<|start_header_id|>' + message['role'] + '<|end_header_id|>\n\n'+ message['content'] | trim + '<|eot_id|>' %}{% if loop.index0 == 0 %}{% set content = bos_token + content %}{% endif %}{{ content }}{% endfor %}{{ '<|start_header_id|>assistant<|end_header_id|>\n\n' }}",
+  "clean_up_tokenization_spaces": true,
+  "eos_token": "<|end_of_text|>",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "!",
+  "padding_side": "right",
+  "tokenizer_class": "MiniCPMVTokenizerFast",
+  "truncation_side": "right",
+  "unk_token": "<unk>"
+}