Upload 23 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* 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
+librkllmrt.so filter=lfs diff=lfs merge=lfs -text
+qwen.rkllm filter=lfs diff=lfs merge=lfs -text
+vision_transformer.rknn filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,140 @@
+注意: 由于疑似RKLLM那边的问题, 目前此模型的推理输出结果不正常 (https://github.com/airockchip/rknn-llm/issues/101), 未来修复后这个repo会更新.
+
+NOTE: Due to suspected issues in RKLLM(https://github.com/airockchip/rknn-llm/issues/101) , the model cannot be used normally for inference at the moment. Once fixed, this repo will be updated.
+
+# MiniCPM-V-2_6-rkllm
+
+## (English README see below)
+
+在RK3588上运行强大的MiniCPM-V-2.6 视觉大模型!
+
+- 推理速度(RK3588): 视觉编码器 4.8s(单核) + LLM 填充 2.2s (92 tokens / 42.5 tps) + 解码 3.25 tps
+- 内存占用(RK3588, 默认上下文长度): 视觉编码器 1.9GB + LLM 7.8GB = 9.7GB
+
+## 使用方法
+
+1. 克隆或者下载此仓库到本地. 模型较大, 请确保有足够的磁盘空间.
+   
+2. 开发板的RKNPU2内核驱动版本必须>=0.9.6才能运行这么大的模型. 
+   使用root权限运行以下命令检查驱动版本:
+   ```bash
+   > cat /sys/kernel/debug/rknpu/version 
+   RKNPU driver: v0.9.8
+   ```
+   如果版本过低, 请更新驱动. 你可能需要更新内核, 或查找官方文档以获取帮助.
+   
+3. 安装依赖
+
+```bash
+pip install numpy<2 opencv-python 
+```
+你还需要手动安装rknn-toolkit2-lite2. 
+
+4. 运行
+   
+```bash
+python run_rknn.py
+```
+
+你可以修改`run_rknn.py`中的内容来测试不同的输入.
+
+## 模型转换
+
+#### 准备工作
+
+1. 安装rknn-toolkit2 v2.1.0或更高版本, 以及rkllm-toolkit v1.1.0或更高版本.
+2. 下载此仓库到本地, 但不需要下载`.rkllm`和`.rknn`结尾的模型文件.
+3. 下载MiniCPM-V-2.6的huggingface模型仓库到本地. (https://huggingface.co/openbmb/MiniCPM-V-2_6)
+  
+#### 转换LLM
+
+1. 将此仓库中的`rename_tensors.py`文件复制到MiniCPM-V-2.6的huggingface模型仓库根目录并运行. 稍等片刻, 会生成`model-renamed-00001-of-00004.safetensors`等4个safetensors文件和一个json文件.
+2. 不用管那个json文件, 将那4个safetensors文件移动到此仓库根目录下.
+3. 执行`rkllm-convert.py`. 等一会, 会生成`qwen.rkllm`, 就是转换后的模型.
+
+#### 转换视觉编码器
+
+1. 将此仓库中的`patched_modeling_navit_siglip.py`和`patched_resampler.py`复制到MiniCPM-V-2.6的huggingface模型仓库根目录下, 重命名为`modeling_navit_siglip.py`和`resampler.py`, 替换掉原来的文件.
+
+2. 打开`vision_export_onnx.py`, 修改其中的`MODEL_PATH`为MiniCPM-V-2.6模型文件夹的路径. 然后执行. 等一会, 会生成`vision_encoder.onnx`.
+3. 执行`vision_convert_rknn.py`. 等一会, 会生成`vision_encoder.rknn`, 这就是转换后的视觉编码器.
+
+## 已知问题
+
+- 由于疑似RKLLM中存在的问题, 目前此模型无法正常推理. 
+- 由于RKLLM中存在的问题, 目前视觉编码器和LLM无法同时被加载, 必须先卸载掉视觉编码器, 再重新加载LLM. 如果要推理多次, 必须重复执行卸载和加载操作, 速度非常慢.
+- 视觉编码器转换ONNX的代码取自 https://github.com/sophgo/LLM-TPU/tree/main/models/MiniCPM-V-2_6 , 感谢Sophgo提供的代码. 但是这个转换方法似乎将原模型中的自适应图像分块算法删除了, 可能会导致精度下降.
+
+## 参考
+
+[sophgo/LLM-TPU models/MiniCPM-V-2_6](https://github.com/sophgo/LLM-TPU/tree/main/models/MiniCPM-V-2_6)
+[openbmb/MiniCPM-V-2_6](https://huggingface.co/openbmb/MiniCPM-V-2_6)
+[Qwen/Qwen2-7B](https://huggingface.co/Qwen/Qwen2-7B)
+
+
+## English README
+
+Run the Powerful MiniCPM-V-2.6 Visual Language Model on RK3588!
+
+- Inference speed (RK3588): Visual encoder 4.8s (single core) + LLM filling 2.2s (92 tokens / 42.5 tps) + decoding 3.25 tps
+- Memory usage (RK3588, default context length): Visual encoder 1.9GB + LLM 7.8GB = 9.7GB
+
+## Usage
+
+1. Clone or download this repository locally. The model is large, so make sure you have enough disk space.
+   
+2. The RKNPU2 kernel driver version on the development board must be >=0.9.6 to run such a large model. 
+   Use the following command with root privileges to check the driver version:
+   ```bash
+   > cat /sys/kernel/debug/rknpu/version 
+   RKNPU driver: v0.9.8
+   ```
+   If the version is too low, please update the driver. You may need to update the kernel or refer to official documentation for help.
+   
+3. Install dependencies
+
+```bash
+pip install numpy<2 opencv-python 
+```
+You also need to manually install rknn-toolkit2-lite2.
+
+4. Run
+   
+```bash
+python run_rknn.py
+```
+
+You can modify the content in `run_rknn.py` to test different inputs.
+
+## Model Conversion
+
+#### Preparation
+
+1. Install rknn-toolkit2 v2.1.0 or higher, and rkllm-toolkit v1.1.0 or higher.
+2. Download this repository locally, but you don't need to download the model files ending with `.rkllm` and `.rknn`.
+3. Download the MiniCPM-V-2.6 Hugging Face model repository locally. (https://huggingface.co/openbmb/MiniCPM-V-2_6)
+  
+#### Converting LLM
+
+1. Copy the `rename_tensors.py` file from this repository to the root directory of the MiniCPM-V-2.6 Hugging Face model repository and run it. Wait for a moment, it will generate 4 safetensors files like `model-renamed-00001-of-00004.safetensors` and a json file.
+2. Ignore the json file, move those 4 safetensors files to the root directory of this repository.
+3. Execute `rkllm-convert.py`. After a while, it will generate `qwen.rkllm`, which is the converted model.
+
+#### Converting Visual Encoder
+
+1. Copy `patched_modeling_navit_siglip.py` and `patched_resampler.py` from this repository to the root directory of the MiniCPM-V-2.6 Hugging Face model repository, rename them to `modeling_navit_siglip.py` and `resampler.py`, replacing the original files.
+
+2. Open `vision_export_onnx.py`, modify the `MODEL_PATH` to the path of the MiniCPM-V-2.6 model folder. Then execute it. After a while, it will generate `vision_encoder.onnx`.
+3. Execute `vision_convert_rknn.py`. After a while, it will generate `vision_encoder.rknn`, which is the converted visual encoder.
+
+## Known Issues
+
+- Due to a suspected issue in RKLLM, this model currently cannot perform inference normally.
+- Due to an issue in RKLLM, the visual encoder and LLM cannot be loaded simultaneously at present. The visual encoder must be unloaded first, then the LLM reloaded. If multiple inferences are required, the unloading and loading operations must be repeated, which is very slow.
+- The code for converting the visual encoder to ONNX is taken from https://github.com/sophgo/LLM-TPU/tree/main/models/MiniCPM-V-2_6, thanks to Sophgo for providing the code. However, this conversion method seems to have removed the adaptive image partitioning algorithm from the original model, which may lead to a decrease in accuracy.
+
+## References
+
+[sophgo/LLM-TPU models/MiniCPM-V-2_6](https://github.com/sophgo/LLM-TPU/tree/main/models/MiniCPM-V-2_6)
+[openbmb/MiniCPM-V-2_6](https://huggingface.co/openbmb/MiniCPM-V-2_6)
+[Qwen/Qwen2-7B](https://huggingface.co/Qwen/Qwen2-7B)

added_tokens.json

@@ -0,0 +1,25 @@
+{
+  "</box>": 151651,
+  "</image>": 151647,
+  "</image_id>": 151659,
+  "</point>": 151655,
+  "</quad>": 151653,
+  "</ref>": 151649,
+  "</slice>": 151657,
+  "<box>": 151650,
+  "<image>": 151646,
+  "<image_id>": 151658,
+  "<point>": 151654,
+  "<quad>": 151652,
+  "<ref>": 151648,
+  "<slice>": 151656,
+  "<|endoftext|>": 151643,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|reserved_special_token_0|>": 151660,
+  "<|reserved_special_token_1|>": 151661,
+  "<|reserved_special_token_2|>": 151662,
+  "<|reserved_special_token_3|>": 151663,
+  "<|reserved_special_token_4|>": 151664,
+  "<|reserved_special_token_5|>": 151665
+}

config.json

@@ -0,0 +1,27 @@
+{
+  "architectures": [
+    "Qwen2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "bos_token_id": 151643,
+  "eos_token_id": 151645,
+  "hidden_act": "silu",
+  "hidden_size": 3584,
+  "initializer_range": 0.02,
+  "intermediate_size": 18944,
+  "max_position_embeddings": 32768,
+  "max_window_layers": 28,
+  "model_type": "qwen2",
+  "num_attention_heads": 28,
+  "num_hidden_layers": 28,
+  "num_key_value_heads": 4,
+  "rms_norm_eps": 1e-06,
+  "rope_theta": 1000000.0,
+  "sliding_window": 131072,
+  "tie_word_embeddings": false,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.37.2",
+  "use_cache": true,
+  "use_sliding_window": false,
+  "vocab_size": 151666
+}

generation_config.json

@@ -0,0 +1,7 @@
+{
+  "bos_token_id": 151643,
+  "do_sample": false,
+  "eos_token_id": 151643,
+  "max_new_tokens": 2048,
+  "transformers_version": "4.37.0"
+}

librkllmrt.so

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

model.safetensors.index.json

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

patched_modeling_navit_siglip.py

@@ -0,0 +1,893 @@
+# coding=utf-8
+# Copyright 2024 Google AI and The HuggingFace Team. All rights reserved.
+#
+# 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.
+""" PyTorch Siglip model. """
+# Copied from  HuggingFaceM4/siglip-so400m-14-980-flash-attn2-navit and add tgt_sizes
+
+
+import os
+import math
+import warnings
+from dataclasses import dataclass
+from typing import Any, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn.init import _calculate_fan_in_and_fan_out
+
+from transformers.activations import ACT2FN
+from transformers.modeling_attn_mask_utils import _prepare_4d_attention_mask
+from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling
+from transformers.modeling_utils import PreTrainedModel
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import (
+    ModelOutput,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    is_flash_attn_2_available,
+    logging,
+    replace_return_docstrings,
+)
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+class SiglipVisionConfig(PretrainedConfig):
+    r"""
+    This is the configuration class to store the configuration of a [`SiglipVisionModel`]. It is used to instantiate a
+    Siglip vision encoder according to the specified arguments, defining the model architecture. Instantiating a
+    configuration with the defaults will yield a similar configuration to that of the vision encoder of the Siglip
+    [google/siglip-base-patch16-224](https://huggingface.co/google/siglip-base-patch16-224) architecture.
+    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
+    documentation from [`PretrainedConfig`] for more information.
+    Args:
+        hidden_size (`int`, *optional*, defaults to 768):
+            Dimensionality of the encoder layers and the pooler layer.
+        intermediate_size (`int`, *optional*, defaults to 3072):
+            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
+        num_hidden_layers (`int`, *optional*, defaults to 12):
+            Number of hidden layers in the Transformer encoder.
+        num_attention_heads (`int`, *optional*, defaults to 12):
+            Number of attention heads for each attention layer in the Transformer encoder.
+        num_channels (`int`, *optional*, defaults to 3):
+            Number of channels in the input images.
+        image_size (`int`, *optional*, defaults to 224):
+            The size (resolution) of each image.
+        patch_size (`int`, *optional*, defaults to 16):
+            The size (resolution) of each patch.
+        hidden_act (`str` or `function`, *optional*, defaults to `"gelu_pytorch_tanh"`):
+            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
+            `"relu"`, `"selu"` and `"gelu_new"` ``"quick_gelu"` are supported.
+        layer_norm_eps (`float`, *optional*, defaults to 1e-06):
+            The epsilon used by the layer normalization layers.
+        attention_dropout (`float`, *optional*, defaults to 0.0):
+            The dropout ratio for the attention probabilities.
+    Example:
+    ```python
+    >>> from transformers import SiglipVisionConfig, SiglipVisionModel
+    >>> # Initializing a SiglipVisionConfig with google/siglip-base-patch16-224 style configuration
+    >>> configuration = SiglipVisionConfig()
+    >>> # Initializing a SiglipVisionModel (with random weights) from the google/siglip-base-patch16-224 style configuration
+    >>> model = SiglipVisionModel(configuration)
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "siglip_vision_model"
+
+    def __init__(
+        self,
+        hidden_size=768,
+        intermediate_size=3072,
+        num_hidden_layers=12,
+        num_attention_heads=12,
+        num_channels=3,
+        image_size=224,
+        patch_size=16,
+        hidden_act="gelu_pytorch_tanh",
+        layer_norm_eps=1e-6,
+        attention_dropout=0.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_channels = num_channels
+        self.patch_size = patch_size
+        self.image_size = image_size
+        self.attention_dropout = attention_dropout
+        self.layer_norm_eps = layer_norm_eps
+        self.hidden_act = hidden_act
+
+    @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)
+
+        # get the vision config dict if we are loading from SiglipConfig
+        if config_dict.get("model_type") == "siglip":
+            config_dict = config_dict["vision_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)
+
+
+_CHECKPOINT_FOR_DOC = "google/siglip-base-patch16-224"
+
+SIGLIP_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "google/siglip-base-patch16-224",
+    # See all SigLIP models at https://huggingface.co/models?filter=siglip
+]
+
+if is_flash_attn_2_available():
+    from flash_attn import flash_attn_func, flash_attn_varlen_func
+    from flash_attn.bert_padding import index_first_axis, pad_input, unpad_input  # noqa
+
+
+# Copied from transformers.models.llama.modeling_llama._get_unpad_data
+def _get_unpad_data(attention_mask):
+    seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)
+    indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten()
+    max_seqlen_in_batch = seqlens_in_batch.max().item()
+    cu_seqlens = F.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.torch.int32), (1, 0))
+    return (
+        indices,
+        cu_seqlens,
+        max_seqlen_in_batch,
+    )
+
+
+def _trunc_normal_(tensor, mean, std, a, b):
+    # Cut & paste from PyTorch official master until it's in a few official releases - RW
+    # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
+    def norm_cdf(x):
+        # Computes standard normal cumulative distribution function
+        return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
+
+    if (mean < a - 2 * std) or (mean > b + 2 * std):
+        warnings.warn(
+            "mean is more than 2 std from [a, b] in nn.init.trunc_normal_. "
+            "The distribution of values may be incorrect.",
+            stacklevel=2,
+        )
+
+    # Values are generated by using a truncated uniform distribution and
+    # then using the inverse CDF for the normal distribution.
+    # Get upper and lower cdf values
+    l = norm_cdf((a - mean) / std)
+    u = norm_cdf((b - mean) / std)
+
+    # Uniformly fill tensor with values from [l, u], then translate to
+    # [2l-1, 2u-1].
+    tensor.uniform_(2 * l - 1, 2 * u - 1)
+
+    # Use inverse cdf transform for normal distribution to get truncated
+    # standard normal
+    if tensor.dtype in [torch.float16, torch.bfloat16]:
+        # The `erfinv_` op is not (yet?) defined in float16+cpu, bfloat16+gpu
+        og_dtype = tensor.dtype
+        tensor = tensor.to(torch.float32)
+        tensor.erfinv_()
+        tensor = tensor.to(og_dtype)
+    else:
+        tensor.erfinv_()
+
+    # Transform to proper mean, std
+    tensor.mul_(std * math.sqrt(2.0))
+    tensor.add_(mean)
+
+    # Clamp to ensure it's in the proper range
+    if tensor.dtype == torch.float16:
+        # The `clamp_` op is not (yet?) defined in float16+cpu
+        tensor = tensor.to(torch.float32)
+        tensor.clamp_(min=a, max=b)
+        tensor = tensor.to(torch.float16)
+    else:
+        tensor.clamp_(min=a, max=b)
+
+
+def trunc_normal_tf_(
+    tensor: torch.Tensor, mean: float = 0.0, std: float = 1.0, a: float = -2.0, b: float = 2.0
+) -> torch.Tensor:
+    """Fills the input Tensor with values drawn from a truncated
+    normal distribution. The values are effectively drawn from the
+    normal distribution :math:`\\mathcal{N}(\text{mean}, \text{std}^2)`
+    with values outside :math:`[a, b]` redrawn until they are within
+    the bounds. The method used for generating the random values works
+    best when :math:`a \\leq \text{mean} \\leq b`.
+    NOTE: this 'tf' variant behaves closer to Tensorflow / JAX impl where the
+    bounds [a, b] are applied when sampling the normal distribution with mean=0, std=1.0
+    and the result is subsquently scaled and shifted by the mean and std args.
+    Args:
+        tensor: an n-dimensional `torch.Tensor`
+        mean: the mean of the normal distribution
+        std: the standard deviation of the normal distribution
+        a: the minimum cutoff value
+        b: the maximum cutoff value
+    """
+    with torch.no_grad():
+        _trunc_normal_(tensor, 0, 1.0, a, b)
+        tensor.mul_(std).add_(mean)
+
+
+def variance_scaling_(tensor, scale=1.0, mode="fan_in", distribution="normal"):
+    fan_in, fan_out = _calculate_fan_in_and_fan_out(tensor)
+    if mode == "fan_in":
+        denom = fan_in
+    elif mode == "fan_out":
+        denom = fan_out
+    elif mode == "fan_avg":
+        denom = (fan_in + fan_out) / 2
+
+    variance = scale / denom
+
+    if distribution == "truncated_normal":
+        # constant is stddev of standard normal truncated to (-2, 2)
+        trunc_normal_tf_(tensor, std=math.sqrt(variance) / 0.87962566103423978)
+    elif distribution == "normal":
+        with torch.no_grad():
+            tensor.normal_(std=math.sqrt(variance))
+    elif distribution == "uniform":
+        bound = math.sqrt(3 * variance)
+        with torch.no_grad():
+            tensor.uniform_(-bound, bound)
+    else:
+        raise ValueError(f"invalid distribution {distribution}")
+
+
+def lecun_normal_(tensor):
+    variance_scaling_(tensor, mode="fan_in", distribution="truncated_normal")
+
+
+def default_flax_embed_init(tensor):
+    variance_scaling_(tensor, mode="fan_in", distribution="normal")
+
+
+@dataclass
+# Copied from transformers.models.clip.modeling_clip.CLIPVisionModelOutput with CLIP->Siglip
+class SiglipVisionModelOutput(ModelOutput):
+    """
+    Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states.
+    Args:
+        image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`):
+            The image embeddings obtained by applying the projection layer to the pooler_output.
+        last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+            Sequence of hidden-states at the output of the last layer of the model.
+        hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
+            Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
+            one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`.
+            Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.
+        attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`):
+            Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length,
+            sequence_length)`.
+            Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
+            heads.
+    """
+
+    image_embeds: Optional[torch.FloatTensor] = None
+    last_hidden_state: torch.FloatTensor = None
+    hidden_states: Optional[Tuple[torch.FloatTensor]] = None
+    attentions: Optional[Tuple[torch.FloatTensor]] = None
+
+
+class SiglipVisionEmbeddings(nn.Module):
+    def __init__(self, config: SiglipVisionConfig):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.image_size = config.image_size
+        self.patch_size = config.patch_size
+
+        self.patch_embedding = nn.Conv2d(
+            in_channels=config.num_channels,
+            out_channels=self.embed_dim,
+            kernel_size=self.patch_size,
+            stride=self.patch_size,
+            padding="valid",
+        )
+
+        self.num_patches_per_side = self.image_size // self.patch_size
+        self.num_patches = self.num_patches_per_side**2
+        self.num_positions = self.num_patches
+        self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
+
+        boundaries = torch.arange(1 / self.num_patches_per_side, 1.0, 1 / self.num_patches_per_side)
+
+        nb_patches_h = 32
+        nb_patches_w = 32
+        fractional_coords_h = torch.arange(0, 1 - 1e-6, 1 / nb_patches_h)
+        fractional_coords_w = torch.arange(0, 1 - 1e-6, 1 / nb_patches_w)
+
+        bucket_coords_h = torch.bucketize(fractional_coords_h, boundaries, right=True)
+        bucket_coords_w = torch.bucketize(fractional_coords_w, boundaries, right=True)
+
+        position_ids = (bucket_coords_h[:, None] * self.num_patches_per_side + bucket_coords_w).flatten()
+        self.position_ids = position_ids
+
+    def forward(self, pixel_values: torch.FloatTensor, patch_attention_mask: torch.BoolTensor=None, tgt_sizes: Optional[torch.IntTensor]=None) -> torch.Tensor:
+
+        patch_embeds = self.patch_embedding(pixel_values).view(1, 1152, 1024)
+        embeddings = patch_embeds.transpose(1, 2)
+        embeddings = embeddings + self.position_embedding(self.position_ids)
+        return embeddings
+
+
+class SiglipAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    # Copied from transformers.models.clip.modeling_clip.CLIPAttention.__init__
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.num_heads = config.num_attention_heads
+        self.head_dim = self.embed_dim // self.num_heads
+        if self.head_dim * self.num_heads != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim} and `num_heads`:"
+                f" {self.num_heads})."
+            )
+        self.scale = self.head_dim**-0.5
+        self.dropout = config.attention_dropout
+
+        self.k_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.v_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.q_proj = nn.Linear(self.embed_dim, self.embed_dim)
+        self.out_proj = nn.Linear(self.embed_dim, self.embed_dim)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        """Input shape: Batch x Time x Channel"""
+
+        batch_size, q_len = 1, 1024
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        query_states = query_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = key_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        value_states = value_states.view(batch_size, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+
+        k_v_seq_len = 1024
+        attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) * self.scale
+
+        if attn_weights.size() != (batch_size, self.num_heads, q_len, k_v_seq_len):
+            raise ValueError(
+                f"Attention weights should be of size {(batch_size, self.num_heads, q_len, k_v_seq_len)}, but is"
+                f" {attn_weights.size()}"
+            )
+
+        if attention_mask is not None:
+            if attention_mask.size() != (batch_size, 1, q_len, k_v_seq_len):
+                raise ValueError(
+                    f"Attention mask should be of size {(batch_size, 1, q_len, k_v_seq_len)}, but is {attention_mask.size()}"
+                )
+            attn_weights = attn_weights + attention_mask
+
+        # upcast attention to fp32
+        attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
+        attn_weights = nn.functional.dropout(attn_weights, p=self.dropout, training=self.training)
+        attn_output = torch.matmul(attn_weights, value_states)
+
+        if attn_output.size() != (batch_size, self.num_heads, q_len, self.head_dim):
+            raise ValueError(
+                f"`attn_output` should be of size {(batch_size, self.num_heads, q_len, self.head_dim)}, but is"
+                f" {attn_output.size()}"
+            )
+
+        attn_output = attn_output.transpose(1, 2).contiguous()
+        attn_output = attn_output.reshape(batch_size, q_len, self.embed_dim)
+
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output, attn_weights
+
+
+class SiglipFlashAttention2(SiglipAttention):
+    """
+    Llama flash attention module. This module inherits from `LlamaAttention` as the weights of the module stays
+    untouched. The only required change would be on the forward pass where it needs to correctly call the public API of
+    flash attention and deal with padding tokens in case the input contains any of them.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.is_causal = False  # Hack to make sure we don't use a causal mask
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: Optional[torch.LongTensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor]] = None,
+        output_attentions: bool = False,
+        use_cache: bool = False,
+        **kwargs,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        output_attentions = False
+
+        bsz, q_len, _ = hidden_states.size()
+
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
+
+        # Flash attention requires the input to have the shape
+        # batch_size x seq_length x head_dim x hidden_dim
+        # therefore we just need to keep the original shape
+        query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        key_states = key_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+        value_states = value_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
+
+        kv_seq_len = key_states.shape[-2]
+        if past_key_value is not None:
+            kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx)
+        # cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
+        # query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
+
+        # if past_key_value is not None:
+        #     cache_kwargs = {"sin": sin, "cos": cos}  # Specific to RoPE models
+        #     key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)
+
+        # TODO: These transpose are quite inefficient but Flash Attention requires the layout [batch_size, sequence_length, num_heads, head_dim]. We would need to refactor the KV cache
+        # to be able to avoid many of these transpose/reshape/view.
+        query_states = query_states.transpose(1, 2)
+        key_states = key_states.transpose(1, 2)
+        value_states = value_states.transpose(1, 2)
+
+        dropout_rate = self.dropout if self.training else 0.0
+
+        # In PEFT, usually we cast the layer norms in float32 for training stability reasons
+        # therefore the input hidden states gets silently casted in float32. Hence, we need
+        # cast them back in the correct dtype just to be sure everything works as expected.
+        # This might slowdown training & inference so it is recommended to not cast the LayerNorms
+        # in fp32. (LlamaRMSNorm handles it correctly)
+
+        input_dtype = query_states.dtype
+        if input_dtype == torch.float32:
+            if torch.is_autocast_enabled():
+                target_dtype = torch.get_autocast_gpu_dtype()
+            # Handle the case where the model is quantized
+            elif hasattr(self.config, "_pre_quantization_dtype"):
+                target_dtype = self.config._pre_quantization_dtype
+            else:
+                target_dtype = self.q_proj.weight.dtype
+
+            logger.warning_once(
+                "The input hidden states seems to be silently casted in float32, this might be related to the fact"
+                " you have upcasted embedding or layer norm layers in float32. We will cast back the input in"
+                f" {target_dtype}."
+            )
+
+            query_states = query_states.to(target_dtype)
+            key_states = key_states.to(target_dtype)
+            value_states = value_states.to(target_dtype)
+
+        attn_output = self._flash_attention_forward(
+            query_states, key_states, value_states, attention_mask, q_len, dropout=dropout_rate
+        )
+
+        attn_output = attn_output.reshape(bsz, q_len, self.embed_dim).contiguous()
+        attn_output = self.out_proj(attn_output)
+
+        if not output_attentions:
+            attn_weights = None
+
+        return attn_output, attn_weights
+
+    def _flash_attention_forward(
+        self, query_states, key_states, value_states, attention_mask, query_length, dropout=0.0, softmax_scale=None
+    ):
+        """
+        Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token
+        first unpad the input, then computes the attention scores and pad the final attention scores.
+        Args:
+            query_states (`torch.Tensor`):
+                Input query states to be passed to Flash Attention API
+            key_states (`torch.Tensor`):
+                Input key states to be passed to Flash Attention API
+            value_states (`torch.Tensor`):
+                Input value states to be passed to Flash Attention API
+            attention_mask (`torch.Tensor`):
+                The padding mask - corresponds to a tensor of size `(batch_size, seq_len)` where 0 stands for the
+                position of padding tokens and 1 for the position of non-padding tokens.
+            dropout (`int`, *optional*):
+                Attention dropout
+            softmax_scale (`float`, *optional*):
+                The scaling of QK^T before applying softmax. Default to 1 / sqrt(head_dim)
+        """
+
+        # TODO: Remove the `query_length != 1` check once Flash Attention for RoCm is bumped to 2.1. For details, please see the comment in LlamaFlashAttention2 __init__.
+        causal = self.is_causal and query_length != 1
+
+        # Contains at least one padding token in the sequence
+        if attention_mask is not None:
+            batch_size = query_states.shape[0]
+            query_states, key_states, value_states, indices_q, cu_seq_lens, max_seq_lens = self._upad_input(
+                query_states, key_states, value_states, attention_mask, query_length
+            )
+
+            cu_seqlens_q, cu_seqlens_k = cu_seq_lens
+            max_seqlen_in_batch_q, max_seqlen_in_batch_k = max_seq_lens
+
+            attn_output_unpad = flash_attn_varlen_func(
+                query_states,
+                key_states,
+                value_states,
+                cu_seqlens_q=cu_seqlens_q,
+                cu_seqlens_k=cu_seqlens_k,
+                max_seqlen_q=max_seqlen_in_batch_q,
+                max_seqlen_k=max_seqlen_in_batch_k,
+                dropout_p=dropout,
+                softmax_scale=softmax_scale,
+                causal=causal,
+            )
+
+            attn_output = pad_input(attn_output_unpad, indices_q, batch_size, query_length)
+        else:
+            attn_output = flash_attn_func(
+                query_states, key_states, value_states, dropout, softmax_scale=softmax_scale, causal=causal
+            )
+
+        return attn_output
+
+    def _upad_input(self, query_layer, key_layer, value_layer, attention_mask, query_length):
+        indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask)
+        batch_size, kv_seq_len, num_key_value_heads, head_dim = key_layer.shape
+
+        key_layer = index_first_axis(
+            key_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
+        )
+        value_layer = index_first_axis(
+            value_layer.reshape(batch_size * kv_seq_len, num_key_value_heads, head_dim), indices_k
+        )
+        if query_length == kv_seq_len:
+            query_layer = index_first_axis(
+                query_layer.reshape(batch_size * kv_seq_len, self.num_heads, head_dim), indices_k
+            )
+            cu_seqlens_q = cu_seqlens_k
+            max_seqlen_in_batch_q = max_seqlen_in_batch_k
+            indices_q = indices_k
+        elif query_length == 1:
+            max_seqlen_in_batch_q = 1
+            cu_seqlens_q = torch.arange(
+                batch_size + 1, dtype=torch.int32, device=query_layer.device
+            )  # There is a memcpy here, that is very bad.
+            indices_q = cu_seqlens_q[:-1]
+            query_layer = query_layer.squeeze(1)
+        else:
+            # The -q_len: slice assumes left padding.
+            attention_mask = attention_mask[:, -query_length:]
+            query_layer, indices_q, cu_seqlens_q, max_seqlen_in_batch_q = unpad_input(query_layer, attention_mask)
+
+        return (
+            query_layer,
+            key_layer,
+            value_layer,
+            indices_q,
+            (cu_seqlens_q, cu_seqlens_k),
+            (max_seqlen_in_batch_q, max_seqlen_in_batch_k),
+        )
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPMLP with CLIP->Siglip
+class SiglipMLP(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.activation_fn = ACT2FN[config.hidden_act]
+        self.fc1 = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.fc2 = nn.Linear(config.intermediate_size, config.hidden_size)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.fc1(hidden_states)
+        hidden_states = self.activation_fn(hidden_states)
+        hidden_states = self.fc2(hidden_states)
+        return hidden_states
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPEncoderLayer with CLIP->Siglip
+class SiglipEncoderLayer(nn.Module):
+    def __init__(self, config: SiglipVisionConfig):
+        super().__init__()
+        self.embed_dim = config.hidden_size
+        self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
+        self.self_attn = (
+            SiglipAttention(config)
+            if not self._use_flash_attention_2
+            else SiglipFlashAttention2(config)
+        )
+        self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+        self.mlp = SiglipMLP(config)
+        self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor,
+        output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.FloatTensor]:
+        """
+        Args:
+            hidden_states (`torch.FloatTensor`):
+                Input to the layer of shape `(batch, seq_len, embed_dim)`.
+            attention_mask (`torch.FloatTensor`):
+                Attention mask of shape `(batch, 1, q_len, k_v_seq_len)` where padding elements are indicated by very large negative values.
+            output_attentions (`bool`, *optional*, defaults to `False`):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+        """
+        residual = hidden_states
+
+        hidden_states = self.layer_norm1(hidden_states)
+        hidden_states, attn_weights = self.self_attn(
+            hidden_states=hidden_states,
+            attention_mask=attention_mask,
+            output_attentions=output_attentions,
+        )
+        hidden_states = residual + hidden_states
+
+        residual = hidden_states
+        hidden_states = self.layer_norm2(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+        hidden_states = residual + hidden_states
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (attn_weights,)
+
+        return outputs
+
+
+class SiglipPreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = SiglipVisionConfig
+    base_model_prefix = "siglip"
+    supports_gradient_checkpointing = True
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+
+        if isinstance(module, SiglipVisionEmbeddings):
+            width = self.config.hidden_size
+            nn.init.normal_(module.position_embedding.weight, std=1 / np.sqrt(width))
+        elif isinstance(module, nn.Embedding):
+            default_flax_embed_init(module.weight)
+        elif isinstance(module, SiglipAttention):
+            nn.init.normal_(module.q_proj.weight)
+            nn.init.normal_(module.k_proj.weight)
+            nn.init.normal_(module.v_proj.weight)
+            nn.init.normal_(module.out_proj.weight)
+            nn.init.zeros_(module.q_proj.bias)
+            nn.init.zeros_(module.k_proj.bias)
+            nn.init.zeros_(module.v_proj.bias)
+            nn.init.zeros_(module.out_proj.bias)
+        elif isinstance(module, SiglipMLP):
+            nn.init.normal_(module.fc1.weight)
+            nn.init.normal_(module.fc2.weight)
+            nn.init.normal_(module.fc1.bias, std=1e-6)
+            nn.init.normal_(module.fc2.bias, std=1e-6)
+        elif isinstance(module, (nn.Linear, nn.Conv2d)):
+            lecun_normal_(module.weight)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+
+SIGLIP_START_DOCSTRING = r"""
+    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
+    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
+    etc.)
+    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
+    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
+    and behavior.
+    Parameters:
+        config ([`SiglipVisionConfig`]): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+
+SIGLIP_VISION_INPUTS_DOCSTRING = r"""
+    Args:
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using
+            [`AutoImageProcessor`]. See [`CLIPImageProcessor.__call__`] for details.
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+# Copied from transformers.models.clip.modeling_clip.CLIPEncoder with CLIP->Siglip
+class SiglipEncoder(nn.Module):
+    """
+    Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a
+    [`SiglipEncoderLayer`].
+    Args:
+        config: SiglipConfig
+    """
+
+    def __init__(self, config: SiglipVisionConfig):
+        super().__init__()
+        self.config = config
+        self.layers = nn.ModuleList([SiglipEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    # Ignore copy
+    def forward(
+        self,
+        inputs_embeds,
+        attention_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutput]:
+        r"""
+        Args:
+            inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`):
+                Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation.
+                This is useful if you want more control over how to convert `input_ids` indices into associated vectors
+                than the model's internal embedding lookup matrix.
+            attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
+                - 1 for tokens that are **not masked**,
+                - 0 for tokens that are **masked**.
+                [What are attention masks?](../glossary#attention-mask)
+            output_attentions (`bool`, *optional*):
+                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
+                returned tensors for more detail.
+            output_hidden_states (`bool`, *optional*):
+                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors
+                for more detail.
+            return_dict (`bool`, *optional*):
+                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        encoder_states = () if output_hidden_states else None
+        all_attentions = () if output_attentions else None
+
+        hidden_states = inputs_embeds
+        for encoder_layer in self.layers:
+            if output_hidden_states:
+                encoder_states = encoder_states + (hidden_states,)
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = self._gradient_checkpointing_func(
+                    encoder_layer.__call__,
+                    hidden_states,
+                    attention_mask,
+                    output_attentions,
+                )
+            else:
+                layer_outputs = encoder_layer(
+                    hidden_states,
+                    attention_mask,
+                    output_attentions=output_attentions,
+                )
+
+            hidden_states = layer_outputs[0]
+
+            if output_attentions:
+                all_attentions = all_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            encoder_states = encoder_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, encoder_states, all_attentions] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states, hidden_states=encoder_states, attentions=all_attentions
+        )
+
+@add_start_docstrings(
+    """The vision model from SigLIP without any head or projection on top.""",
+    SIGLIP_START_DOCSTRING
+)
+class SiglipVisionTransformer(SiglipPreTrainedModel):
+    config_class = SiglipVisionConfig
+    main_input_name = "pixel_values"
+    _supports_flash_attn_2 = True
+
+    def __init__(self, config: SiglipVisionConfig):
+        super().__init__(config)
+        self.config = config
+        embed_dim = config.hidden_size
+
+        self.embeddings = SiglipVisionEmbeddings(config)
+        self.encoder = SiglipEncoder(config)
+        self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+        self._use_flash_attention_2 = config._attn_implementation == "flash_attention_2"
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self) -> nn.Module:
+        return self.embeddings.patch_embedding
+
+    @add_start_docstrings_to_model_forward(SIGLIP_VISION_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=BaseModelOutputWithPooling, config_class=SiglipVisionConfig)
+    def forward(
+        self,
+        pixel_values,
+        patch_attention_mask: Optional[torch.BoolTensor] = None,
+        tgt_sizes: Optional[torch.IntTensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        r"""
+        Returns:
+        """
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        hidden_states = self.embeddings(pixel_values=pixel_values, patch_attention_mask=patch_attention_mask, tgt_sizes=tgt_sizes)
+
+        encoder_outputs = self.encoder(
+            inputs_embeds=hidden_states,
+            attention_mask=None,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        last_hidden_state = encoder_outputs[0]
+        last_hidden_state = self.post_layernorm(last_hidden_state)
+
+        if not return_dict:
+            return (last_hidden_state, None) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPooling(
+            last_hidden_state=last_hidden_state,
+            pooler_output=None,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )

patched_resampler.py

@@ -0,0 +1,771 @@
+from functools import partial
+from typing import Optional, Tuple
+import numpy as np
+import warnings
+
+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_, constant_, xavier_normal_, xavier_uniform_
+
+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)
+        self._adjust_pos_cache([32,32])
+        pos_embed = []
+        # for i in range(bs):
+        tgt_h, tgt_w = 32, 32
+        pos_embed.append(self.pos_embed[:tgt_h, :tgt_w, :].reshape((tgt_h * tgt_w, -1)))  # patches * D
+        # key_padding_mask[:, patch_len:] = True
+        self.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
+
+    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 = 32
+        max_w = 32
+        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):
+        dtype = x.dtype
+
+
+        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(
+            q.unsqueeze(1),  # Q * B * D
+            x + self.pos_embed.to(dtype),  # L * B * D +  L * B * D
+            x,
+            key_padding_mask=None)[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 = _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 = _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)
+
+        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 = 28, 64, 128
+            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)

qwen.rkllm

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

rename_tensors.py

@@ -0,0 +1,46 @@
+import json
+import os
+import shutil
+import mmap
+import re
+
+def rename_tensors():
+    # 读取JSON文件
+    with open('model.safetensors.index.json', 'r') as f:
+        data = json.load(f)
+
+    # 获取所有唯一的safetensors文件名
+    safetensor_files = set(data['weight_map'].values())
+
+    # 复制并重命名safetensors文件
+    for file in safetensor_files:
+        new_file = file.replace('model-', 'model-renamed-')
+        shutil.copy(file, new_file)
+
+        # 在新文件的前1MB范围内替换字符串
+        with open(new_file, 'r+b') as f:
+            mm = mmap.mmap(f.fileno(), 1024*1024)  # 映射前1MB
+            content = mm.read()
+            # 使用字节字符串进行替换
+            content = content.replace(b'"llm.', b'    "')
+            mm.seek(0)
+            mm.write(content)
+            mm.close()
+
+    # 更新JSON数据
+    new_weight_map = {}
+    for key, value in data['weight_map'].items():
+        new_key = re.sub(r'^llm\.', '', key)
+        new_value = value.replace('model-', 'model-renamed-')
+        new_weight_map[new_key] = new_value
+
+    data['weight_map'] = new_weight_map
+
+    # 写入新的JSON文件
+    with open('model-renamed.safetensors.index.json', 'w') as f:
+        json.dump(data, f, indent=2)
+
+    print("处理完成。新的JSON文件已生成：model-renamed.safetensors.index.json")
+
+if __name__ == "__main__":
+    rename_tensors()

rkllm-convert.py

@@ -0,0 +1,23 @@
+from rkllm.api import RKLLM
+
+modelpath = '.'
+llm = RKLLM()
+
+ret = llm.load_huggingface(model=modelpath, model_lora=None, device='cpu')
+if ret != 0:
+    print('Load model failed!')
+    exit(ret)
+
+qparams = None
+ret = llm.build(do_quantization=True, optimization_level=1, quantized_dtype='w8a8_g128',
+                quantized_algorithm='normal', target_platform='rk3588', num_npu_core=3, extra_qparams=qparams)
+
+if ret != 0:
+    print('Build model failed!')
+    exit(ret)
+
+# Export rkllm model
+ret = llm.export_rkllm("./qwen.rkllm")
+if ret != 0:
+    print('Export model failed!')
+    exit(ret)

rkllm_binding.py

@@ -0,0 +1,227 @@
+import ctypes
+import numpy as np
+from enum import IntEnum
+from typing import Callable, Any
+
+# Load the shared library
+_lib = ctypes.CDLL("librkllmrt.so")  # Adjust the library name if necessary
+
+# Define enums
+class LLMCallState(IntEnum):
+    RKLLM_RUN_NORMAL = 0
+    RKLLM_RUN_WAITING = 1
+    RKLLM_RUN_FINISH = 2
+    RKLLM_RUN_ERROR = 3
+    RKLLM_RUN_GET_LAST_HIDDEN_LAYER = 4
+
+class RKLLMInputType(IntEnum):
+    RKLLM_INPUT_PROMPT = 0
+    RKLLM_INPUT_TOKEN = 1
+    RKLLM_INPUT_EMBED = 2
+    RKLLM_INPUT_MULTIMODAL = 3
+
+class RKLLMInferMode(IntEnum):
+    RKLLM_INFER_GENERATE = 0
+    RKLLM_INFER_GET_LAST_HIDDEN_LAYER = 1
+
+# Define structures
+class RKLLMExtendParam(ctypes.Structure):
+    _fields_ = [
+        ("base_domain_id", ctypes.c_int32),
+        ("reserved", ctypes.c_uint8 * 112)
+    ]
+
+class RKLLMParam(ctypes.Structure):
+    _fields_ = [
+        ("model_path", ctypes.c_char_p),
+        ("max_context_len", ctypes.c_int32),
+        ("max_new_tokens", ctypes.c_int32),
+        ("top_k", ctypes.c_int32),
+        ("top_p", ctypes.c_float),
+        ("temperature", ctypes.c_float),
+        ("repeat_penalty", ctypes.c_float),
+        ("frequency_penalty", ctypes.c_float),
+        ("presence_penalty", ctypes.c_float),
+        ("mirostat", ctypes.c_int32),
+        ("mirostat_tau", ctypes.c_float),
+        ("mirostat_eta", ctypes.c_float),
+        ("skip_special_token", ctypes.c_bool),
+        ("is_async", ctypes.c_bool),
+        ("img_start", ctypes.c_char_p),
+        ("img_end", ctypes.c_char_p),
+        ("img_content", ctypes.c_char_p),
+        ("extend_param", RKLLMExtendParam)
+    ]
+
+class RKLLMLoraAdapter(ctypes.Structure):
+    _fields_ = [
+        ("lora_adapter_path", ctypes.c_char_p),
+        ("lora_adapter_name", ctypes.c_char_p),
+        ("scale", ctypes.c_float)
+    ]
+
+class RKLLMEmbedInput(ctypes.Structure):
+    _fields_ = [
+        ("embed", ctypes.POINTER(ctypes.c_float)),
+        ("n_tokens", ctypes.c_size_t)
+    ]
+
+class RKLLMTokenInput(ctypes.Structure):
+    _fields_ = [
+        ("input_ids", ctypes.POINTER(ctypes.c_int32)),
+        ("n_tokens", ctypes.c_size_t)
+    ]
+
+class RKLLMMultiModelInput(ctypes.Structure):
+    _fields_ = [
+        ("prompt", ctypes.c_char_p),
+        ("image_embed", ctypes.POINTER(ctypes.c_float)),
+        ("n_image_tokens", ctypes.c_size_t)
+    ]
+
+class RKLLMInput(ctypes.Structure):
+    class _InputUnion(ctypes.Union):
+        _fields_ = [
+            ("prompt_input", ctypes.c_char_p),
+            ("embed_input", RKLLMEmbedInput),
+            ("token_input", RKLLMTokenInput),
+            ("multimodal_input", RKLLMMultiModelInput)
+        ]
+    _fields_ = [
+        ("input_type", ctypes.c_int),
+        ("_input", _InputUnion)
+    ]
+
+class RKLLMLoraParam(ctypes.Structure):
+    _fields_ = [
+        ("lora_adapter_name", ctypes.c_char_p)
+    ]
+
+class RKLLMPromptCacheParam(ctypes.Structure):
+    _fields_ = [
+        ("save_prompt_cache", ctypes.c_int),
+        ("prompt_cache_path", ctypes.c_char_p)
+    ]
+
+class RKLLMInferParam(ctypes.Structure):
+    _fields_ = [
+        ("mode", ctypes.c_int),
+        ("lora_params", ctypes.POINTER(RKLLMLoraParam)),
+        ("prompt_cache_params", ctypes.POINTER(RKLLMPromptCacheParam))
+    ]
+
+class RKLLMResultLastHiddenLayer(ctypes.Structure):
+    _fields_ = [
+        ("hidden_states", ctypes.POINTER(ctypes.c_float)),
+        ("embd_size", ctypes.c_int),
+        ("num_tokens", ctypes.c_int)
+    ]
+
+class RKLLMResult(ctypes.Structure):
+    _fields_ = [
+        ("text", ctypes.c_char_p),
+        ("token_id", ctypes.c_int32),
+        ("last_hidden_layer", RKLLMResultLastHiddenLayer)
+    ]
+
+# Define callback type
+LLMResultCallback = ctypes.CFUNCTYPE(None, ctypes.POINTER(RKLLMResult), ctypes.c_void_p, ctypes.c_int)
+
+# Define function prototypes
+_lib.rkllm_createDefaultParam.restype = RKLLMParam
+_lib.rkllm_init.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(RKLLMParam), LLMResultCallback]
+_lib.rkllm_init.restype = ctypes.c_int
+_lib.rkllm_load_lora.argtypes = [ctypes.c_void_p, ctypes.POINTER(RKLLMLoraAdapter)]
+_lib.rkllm_load_lora.restype = ctypes.c_int
+_lib.rkllm_load_prompt_cache.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+_lib.rkllm_load_prompt_cache.restype = ctypes.c_int
+_lib.rkllm_release_prompt_cache.argtypes = [ctypes.c_void_p]
+_lib.rkllm_release_prompt_cache.restype = ctypes.c_int
+_lib.rkllm_destroy.argtypes = [ctypes.c_void_p]
+_lib.rkllm_destroy.restype = ctypes.c_int
+_lib.rkllm_run.argtypes = [ctypes.c_void_p, ctypes.POINTER(RKLLMInput), ctypes.POINTER(RKLLMInferParam), ctypes.c_void_p]
+_lib.rkllm_run.restype = ctypes.c_int
+_lib.rkllm_run_async.argtypes = [ctypes.c_void_p, ctypes.POINTER(RKLLMInput), ctypes.POINTER(RKLLMInferParam), ctypes.c_void_p]
+_lib.rkllm_run_async.restype = ctypes.c_int
+_lib.rkllm_abort.argtypes = [ctypes.c_void_p]
+_lib.rkllm_abort.restype = ctypes.c_int
+_lib.rkllm_is_running.argtypes = [ctypes.c_void_p]
+_lib.rkllm_is_running.restype = ctypes.c_int
+
+# Python wrapper functions
+def create_default_param() -> RKLLMParam:
+    return _lib.rkllm_createDefaultParam()
+
+def init(param: RKLLMParam, callback: Callable[[RKLLMResult, Any, LLMCallState], None]) -> ctypes.c_void_p:
+    handle = ctypes.c_void_p()
+    c_callback = LLMResultCallback(callback)
+    status = _lib.rkllm_init(ctypes.byref(handle), ctypes.byref(param), c_callback)
+    if status != 0:
+        raise RuntimeError(f"Failed to initialize RKLLM: {status}")
+    return handle
+
+def load_lora(handle: ctypes.c_void_p, lora_adapter: RKLLMLoraAdapter) -> None:
+    status = _lib.rkllm_load_lora(handle, ctypes.byref(lora_adapter))
+    if status != 0:
+        raise RuntimeError(f"Failed to load Lora adapter: {status}")
+
+def load_prompt_cache(handle: ctypes.c_void_p, prompt_cache_path: str) -> None:
+    status = _lib.rkllm_load_prompt_cache(handle, prompt_cache_path.encode())
+    if status != 0:
+        raise RuntimeError(f"Failed to load prompt cache: {status}")
+
+def release_prompt_cache(handle: ctypes.c_void_p) -> None:
+    status = _lib.rkllm_release_prompt_cache(handle)
+    if status != 0:
+        raise RuntimeError(f"Failed to release prompt cache: {status}")
+
+def destroy(handle: ctypes.c_void_p) -> None:
+    status = _lib.rkllm_destroy(handle)
+    if status != 0:
+        raise RuntimeError(f"Failed to destroy RKLLM: {status}")
+
+def run(handle: ctypes.c_void_p, rkllm_input: RKLLMInput, rkllm_infer_params: RKLLMInferParam, userdata: Any) -> None:
+    status = _lib.rkllm_run(handle, ctypes.byref(rkllm_input), ctypes.byref(rkllm_infer_params), userdata)
+    if status != 0:
+        raise RuntimeError(f"Failed to run RKLLM: {status}")
+
+def run_async(handle: ctypes.c_void_p, rkllm_input: RKLLMInput, rkllm_infer_params: RKLLMInferParam, userdata: Any) -> None:
+    status = _lib.rkllm_run_async(handle, ctypes.byref(rkllm_input), ctypes.byref(rkllm_infer_params), userdata)
+    if status != 0:
+        raise RuntimeError(f"Failed to run RKLLM asynchronously: {status}")
+
+def abort(handle: ctypes.c_void_p) -> None:
+    status = _lib.rkllm_abort(handle)
+    if status != 0:
+        raise RuntimeError(f"Failed to abort RKLLM: {status}")
+
+def is_running(handle: ctypes.c_void_p) -> bool:
+    return _lib.rkllm_is_running(handle) == 0
+
+# Helper function to convert numpy array to C array
+def numpy_to_c_array(arr: np.ndarray, c_type):
+    return arr.ctypes.data_as(ctypes.POINTER(c_type))
+
+# Helper function to create RKLLMInput
+def create_rkllm_input(input_type: RKLLMInputType, **kwargs) -> RKLLMInput:
+    rkllm_input = RKLLMInput()
+    rkllm_input.input_type = input_type.value
+
+    if input_type == RKLLMInputType.RKLLM_INPUT_PROMPT:
+        rkllm_input._input.prompt_input = kwargs['prompt'].encode()
+    elif input_type == RKLLMInputType.RKLLM_INPUT_EMBED:
+        embed = kwargs['embed']
+        rkllm_input._input.embed_input.embed = numpy_to_c_array(embed, ctypes.c_float)
+        # rkllm_input._input.embed_input.n_tokens = embed.shape[1]
+        rkllm_input._input.embed_input.n_tokens = embed.shape[2]
+    elif input_type == RKLLMInputType.RKLLM_INPUT_TOKEN:
+        tokens = kwargs['tokens']
+        rkllm_input._input.token_input.input_ids = numpy_to_c_array(tokens, ctypes.c_int32)
+        rkllm_input._input.token_input.n_tokens = tokens.shape[1]
+    elif input_type == RKLLMInputType.RKLLM_INPUT_MULTIMODAL:
+        rkllm_input._input.multimodal_input.prompt = kwargs['prompt'].encode()
+        image_embed = kwargs['image_embed']
+        rkllm_input._input.multimodal_input.image_embed = numpy_to_c_array(image_embed, ctypes.c_float)
+        rkllm_input._input.multimodal_input.n_image_tokens = image_embed.shape[1]
+
+    return rkllm_input

run_rknn.py

@@ -0,0 +1,121 @@
+import os
+import time
+import numpy as np
+from rkllm_binding import *
+from rknnlite.api.rknn_lite import RKNNLite
+import signal
+import cv2
+
+MODEL_PATH = "/home/firefly/qwen.rkllm"
+VISION_ENCODER_PATH = "vision_transformer.rknn"
+handle = None
+img_size = 448
+
+# exit on ctrl-c
+def signal_handler(signal, frame):
+    print("Ctrl-C pressed, exiting...")
+    global handle
+    if handle:
+        abort(handle)
+        destroy(handle)
+    exit(0)
+
+signal.signal(signal.SIGINT, signal_handler)
+
+# export RKLLM_LOG_LEVEL=1
+os.environ["RKLLM_LOG_LEVEL"] = "1"
+
+inference_count = 0
+inference_start_time = 0
+def result_callback(result, userdata, state):
+    global inference_start_time
+    global inference_count
+    if state == LLMCallState.RKLLM_RUN_NORMAL:
+        if inference_count == 0:
+            first_token_time = time.time()
+            print(f"Time to first token: {first_token_time - inference_start_time:.2f} seconds")
+        inference_count += 1
+        print(result.contents.text.decode(), end="", flush=True)
+    elif state == LLMCallState.RKLLM_RUN_FINISH:
+        print("\n\n(finished)")
+    elif state == LLMCallState.RKLLM_RUN_ERROR:
+        print("\nError occurred during LLM call")
+
+# Initialize vision encoder
+vision_encoder = RKNNLite(verbose=False)
+model_size = os.path.getsize(VISION_ENCODER_PATH)
+print(f"Start loading vision encoder model (size: {model_size / 1024 / 1024:.2f} MB)")
+start_time = time.time()
+vision_encoder.load_rknn(VISION_ENCODER_PATH)
+end_time = time.time()
+print(f"Vision encoder loaded in {end_time - start_time:.2f} seconds (speed: {model_size / (end_time - start_time) / 1024 / 1024:.2f} MB/s)")
+vision_encoder.init_runtime()
+
+# image embedding
+img_path = "test.jpg"
+
+normalize_mean = 0.5
+normalize_std = 0.5
+
+img = cv2.imread(img_path)
+img = cv2.resize(img, (img_size, img_size))
+# img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+img = img.astype(np.float32)
+# img = img / 255.0
+# img = (img - normalize_mean) / normalize_std
+img = img[np.newaxis, :, :, :]
+print(img.shape)
+start_time = time.time()
+image_embeddings = vision_encoder.inference(inputs=[img.astype(np.float32)], data_type="float32", data_format="nhwc")[0]
+end_time = time.time()
+print(f"Vision encoder inference time: {end_time - start_time:.2f} seconds")
+print(image_embeddings.flags)
+print(image_embeddings.shape)
+np.save("image_embeddings_rknn.npy", image_embeddings)
+
+
+vision_encoder.release() # free memory, rockchip plz fix this
+
+# Initialize RKLLM
+param = create_default_param()
+param.model_path = MODEL_PATH.encode()
+param.img_start = "<image>".encode()
+param.img_end = "</image>".encode()
+param.img_content = "<unk>".encode()
+extend_param = RKLLMExtendParam()
+extend_param.base_domain_id = 0  # iommu domain 0 for vision encoder
+param.extend_param = extend_param
+model_size = os.path.getsize(MODEL_PATH)
+print(f"Start loading language model (size: {model_size / 1024 / 1024:.2f} MB)")
+start_time = time.time()
+handle = init(param, result_callback)
+end_time = time.time()
+print(f"Language model loaded in {end_time - start_time:.2f} seconds (speed: {model_size / (end_time - start_time) / 1024 / 1024:.2f} MB/s)")
+
+# Create input
+prompt = """<|im_start|>system
+You are a helpful assistant.<|im_end|>
+<|im_start|>user
+<image>
+详细介绍一下这张图片: <|im_end|>
+<|im_start|>assistant
+
+"""
+# 2.56->3.25>2.41->10.2
+# image_embeddings = np.load("image_embeddings_pth_orig.npy")
+# print(image_embeddings.shape)
+# rkllm_input = create_rkllm_input(RKLLMInputType.RKLLM_INPUT_EMBED, embed=image_embeddings.astype(np.float32))
+
+rkllm_input = create_rkllm_input(RKLLMInputType.RKLLM_INPUT_MULTIMODAL, prompt=prompt, image_embed=image_embeddings.astype(np.float32))
+
+# Create inference parameters
+infer_param = RKLLMInferParam()
+infer_param.mode = RKLLMInferMode.RKLLM_INFER_GENERATE.value
+
+# Run RKLLM
+print("Start inference...")
+inference_start_time = time.time()
+run(handle, rkllm_input, infer_param, None)
+
+# Clean up
+destroy(handle)

special_tokens_map.json

@@ -0,0 +1,172 @@
+{
+  "additional_special_tokens": [
+    {
+      "content": "<image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<image_id>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "</image_id>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_0|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_1|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_2|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_3|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_4|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "<|reserved_special_token_5|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    }
+  ],
+  "bos_token": {
+    "content": "<|im_start|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenization_minicpmv_fast.py

@@ -0,0 +1,66 @@
+from transformers.models.qwen2 import Qwen2TokenizerFast
+
+
+class MiniCPMVTokenizerFast(Qwen2TokenizerFast):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        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>"
+        self.im_id_start = "<image_id>"
+        self.im_id_end = "</image_id>"
+
+    @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 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)
+
+    @property
+    def slice_start_id(self):
+        return self.convert_tokens_to_ids(self.slice_start)
+    
+    @property
+    def slice_end_id(self):
+        return self.convert_tokens_to_ids(self.slice_end)
+
+    @property
+    def im_id_start_id(self):
+        return self.convert_tokens_to_ids(self.im_id_start)
+    
+    @property
+    def im_id_end_id(self):
+        return self.convert_tokens_to_ids(self.im_id_end)
+    
+    @property
+    def newline_id(self):
+        return self.convert_tokens_to_ids('\n')
+
+    @staticmethod
+    def escape(text: str) -> str:
+        return text
+
+    @staticmethod
+    def unescape(text: str) -> str:
+        return text

tokenizer_config.json

@@ -0,0 +1,235 @@
+{
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "128244": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "</image>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "</ref>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "</box>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "</quad>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "</point>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "</slice>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151658": {
+      "content": "<image_id>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151659": {
+      "content": "</image_id>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151660": {
+      "content": "<|reserved_special_token_0|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151661": {
+      "content": "<|reserved_special_token_1|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151662": {
+      "content": "<|reserved_special_token_2|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151663": {
+      "content": "<|reserved_special_token_3|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151664": {
+      "content": "<|reserved_special_token_4|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151665": {
+      "content": "<|reserved_special_token_5|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "<image>",
+    "</image>",
+    "<ref>",
+    "</ref>",
+    "<box>",
+    "</box>",
+    "<quad>",
+    "</quad>",
+    "<point>",
+    "</point>",
+    "<slice>",
+    "</slice>",
+    "<image_id>",
+    "</image_id>",
+    "<|reserved_special_token_0|>",
+    "<|reserved_special_token_1|>",
+    "<|reserved_special_token_2|>",
+    "<|reserved_special_token_3|>",
+    "<|reserved_special_token_4|>",
+    "<|reserved_special_token_5|>"
+  ],
+  "bos_token": "<|im_start|>",
+  "chat_template": "{% for message in messages %}{% if loop.first and messages[0]['role'] != 'system' %}{{ '<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n' }}{% endif %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<|endoftext|>",
+  "split_special_tokens": false,
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_minicpmv_fast.MiniCPMVTokenizerFast",
+      null
+    ]
+  },
+  "tokenizer_class": "MiniCPMVTokenizerFast",
+  "unk_token": "<unk>"
+}

vision_convert_rknn.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import os
+from rknn.api import RKNN
+from sys import exit
+import argparse
+import cv2
+import numpy as np
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+
+image_sizes= [[448, 448]]
+batch_sizes = [1]
+
+def convert_encoder():
+    rknn = RKNN(verbose=True)
+
+    ONNX_MODEL=f"vision_transformer.onnx"
+    RKNN_MODEL=ONNX_MODEL.replace(".onnx",".rknn")
+    DATASET="dataset.txt"
+    QUANTIZE=False
+    input_shapes = [[[batch_size, 3, image_size[0], image_size[1]]] for batch_size in batch_sizes for image_size in image_sizes]
+    print(input_shapes)
+
+    # pre-process config
+    print('--> Config model')
+    rknn.config(quantized_algorithm='normal', quantized_method='channel', target_platform='rk3588', optimization_level=3,
+                mean_values=[128, 128, 128], std_values=[128, 128, 128], dynamic_input=input_shapes) # mean_values=[0.5, 0.5, 0.5], std_values=[0.5, 0.5, 0.5],
+    print('done')
+
+    # Load ONNX model
+    print("--> Loading model")
+    ret = rknn.load_onnx(
+        model=ONNX_MODEL,
+    )
+
+    if ret != 0:
+        print('Load model failed!')
+        exit(ret)
+    print('done')
+
+    # Build model
+    print('--> Building model')
+    ret = rknn.build(do_quantization=QUANTIZE, dataset=DATASET, rknn_batch_size=None)
+    if ret != 0:
+        print('Build model failed!')
+        exit(ret)
+    print('done')
+
+    # export
+    print('--> Export RKNN model')
+    ret = rknn.export_rknn(RKNN_MODEL)
+    if ret != 0:
+        print('Export RKNN model failed!')
+        exit(ret)
+    print('done')
+    rknn.init_runtime(target='rk3588')
+    # # image embedding
+    # img_path = "test.jpg"
+
+    # normalize_mean = [0.5, 0.5, 0.5]
+    # normalize_std = [0.5, 0.5, 0.5]
+
+    # img = cv2.imread(img_path)
+    # img = cv2.resize(img, (448, 448))
+    # # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    # img = img.astype(np.float32)
+    # # img = (img - normalize_mean) / normalize_std
+    # img = img[np.newaxis, :, :, :]
+    # img = img.transpose(0, 3, 1, 2)
+    # np.save("img.npy", img)
+    # rknn.accuracy_analysis(inputs=["img.npy"], target='rk3588')
+# usage: python convert_rknn.py encoder|all
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("model", type=str, help="model to convert", choices=["encoder", "all"], nargs='?')
+    args = parser.parse_args()
+    if args.model is None:
+        args.model = "all"
+    if args.model == "encoder":
+        convert_encoder()
+    elif args.model == "all":
+        convert_encoder()
+    else:
+        print(f"Unknown model: {args.model}")
+        exit(1)

vision_export_onnx.py

@@ -0,0 +1,53 @@
+import os
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+MODEL_PATH = "../MiniCPM-V-2_6/"
+DEVICE_MAP = "cpu"
+
+origin_model = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH, trust_remote_code=True, attn_implementation='eager', device_map=DEVICE_MAP).eval()
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
+
+for param in origin_model.parameters():
+    param.requires_grad = False
+
+class VisionTransformer(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.vpm = origin_model.vpm
+        self.resampler = origin_model.resampler
+        self.tgt_sizes = torch.Tensor([[32, 32]]).type(torch.int32)
+
+    def forward(self, pixel_values):
+        vit_embeds = self.vpm(pixel_values).last_hidden_state
+        vit_embeds = self.resampler(vit_embeds, self.tgt_sizes)
+        return vit_embeds
+
+
+def convert_vision_transformer():
+    model = VisionTransformer()
+    IMAGE_SIZE = 448
+    pixel_values = torch.randn(
+        (1, 3, IMAGE_SIZE, IMAGE_SIZE))
+    
+    # test first
+    vit_embeds = model(pixel_values)
+    print(vit_embeds.shape)  #1x64x3584
+    if vit_embeds.shape != (1, 64, 3584):
+        raise ValueError("vit_embeds shape is not correct, something is wrong")
+
+
+    torch.onnx.export(model, pixel_values,
+                      f'vision_transformer.onnx',
+                      verbose=False,
+                      input_names=['pixel_values'],
+                      output_names=['vit_embeds'],
+                      dynamic_axes={'pixel_values': {0: 'batch_size', 2: 'height', 3: 'width'},
+                                    'vit_embeds': {0: 'batch_size', 1: 'seq_len'}},
+                      do_constant_folding=True,
+                      opset_version=17)
+
+if __name__ == "__main__":
+    convert_vision_transformer()

vision_transformer.rknn

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