Duplicate from StanfordAIMI/CheXagent-8b

Co-authored-by: Zhihong Chen <zhjohnchan@users.noreply.huggingface.co>

.gitattributes

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

README.md

@@ -0,0 +1,61 @@
+<!-- markdownlint-disable first-line-h1 -->
+<!-- markdownlint-disable html -->
+
+<div align="center">
+<h1>
+  CheXagent
+</h1>
+</div>
+
+<p align="center">
+📝 <a href="https://arxiv.org/abs/2401.12208" target="_blank">Paper</a> • 🤗 <a href="https://huggingface.co/StanfordAIMI/CheXagent-8b/" target="_blank">Hugging Face</a> • 🧩 <a href="https://github.com/Stanford-AIMI/CheXagent" target="_blank">Github</a> • 🪄 <a href="https://stanford-aimi.github.io/chexagent.html" target="_blank">Project</a>
+</p>
+
+<div align="center">
+</div>
+
+## ✨ Latest News
+
+- [12/15/2023]: Model released in [Hugging Face](https://huggingface.co/StanfordAIMI/CheXagent-8b/).
+
+## 🎬 Get Started
+
+```python
+import io
+
+import requests
+import torch
+from PIL import Image
+from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfig
+
+# step 1: Setup constant
+device = "cuda"
+dtype = torch.float16
+
+# step 2: Load Processor and Model
+processor = AutoProcessor.from_pretrained("StanfordAIMI/CheXagent-8b", trust_remote_code=True)
+generation_config = GenerationConfig.from_pretrained("StanfordAIMI/CheXagent-8b")
+model = AutoModelForCausalLM.from_pretrained("StanfordAIMI/CheXagent-8b", torch_dtype=dtype, trust_remote_code=True)
+
+# step 3: Fetch the images
+image_path = "https://upload.wikimedia.org/wikipedia/commons/3/3b/Pleural_effusion-Metastatic_breast_carcinoma_Case_166_%285477628658%29.jpg"
+images = [Image.open(io.BytesIO(requests.get(image_path).content)).convert("RGB")]
+
+# step 4: Generate the Findings section
+prompt = f'Describe "Airway"'
+inputs = processor(images=images, text=f" USER: <s>{prompt} ASSISTANT: <s>", return_tensors="pt").to(device=device, dtype=dtype)
+output = model.generate(**inputs, generation_config=generation_config)[0]
+response = processor.tokenizer.decode(output, skip_special_tokens=True)
+```
+
+## ✏️ Citation
+
+```
+@article{chexagent-2024,
+  title={CheXagent: Towards a Foundation Model for Chest X-Ray Interpretation},
+  author={Chen, Zhihong and Varma, Maya and Delbrouck, Jean-Benoit and Paschali, Magdalini and Blankemeier, Louis and Veen, Dave Van and Valanarasu, Jeya Maria Jose and Youssef, Alaa and Cohen, Joseph Paul and Reis, Eduardo Pontes and Tsai, Emily B. and Johnston, Andrew and Olsen, Cameron and Abraham, Tanishq Mathew and Gatidis, Sergios and Chaudhari, Akshay S and Langlotz, Curtis},
+  journal={arXiv preprint arXiv:2401.12208},
+  url={https://arxiv.org/abs/2401.12208},
+  year={2024}
+}
+```

config.json

@@ -0,0 +1,54 @@
+{
+  "_name_or_path": "StanfordAIMI/CheXagent-8b",
+  "architectures": [
+    "CheXagentForConditionalGeneration"
+  ],
+  "initializer_factor": 1.0,
+  "initializer_range": 0.02,
+  "model_type": "chexagent",
+  "num_max_images": 2,
+  "num_query_tokens": 128,
+  "qformer_config": {
+    "model_type": "chexagent_qformer",
+    "vocab_size": 30523
+  },
+  "text_config": {
+    "_name_or_path": "mistralai/Mistral-7B-v0.1",
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "attention_bias": false,
+    "bos_token_id": 1,
+    "hidden_act": "silu",
+    "hidden_size": 4096,
+    "initializer_range": 0.02,
+    "intermediate_size": 14336,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_hidden_layers": 32,
+    "num_key_value_heads": 8,
+    "pad_token_id": null,
+    "pretraining_tp": 1,
+    "rms_norm_eps": 1e-05,
+    "rope_scaling": null,
+    "rope_theta": 10000.0,
+    "sliding_window": 4096,
+    "tie_word_embeddings": false,
+    "torch_dtype": "bfloat16",
+    "vocab_size": 32000
+  },
+  "tie_word_embeddings": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.35.2",
+  "use_decoder_only_language_model": true,
+  "vision_config": {
+    "image_size": 448,
+    "model_type": "chexagent_vision_model",
+    "num_hidden_layers": 40
+  },
+  "auto_map": {
+    "AutoModelForCausalLM": "modeling_chexagent.CheXagentForConditionalGeneration",
+    "AutoConfig": "configuration_chexagent.CheXagentConfig"
+  }
+}

configuration_chexagent.py

@@ -0,0 +1,180 @@
+# coding=utf-8
+# Copyright 2023 The CheXagent Authors and The HuggingFace Inc. 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.
+
+import os
+from typing import Union
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.models.auto import CONFIG_MAPPING
+from transformers.models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class CheXagentVisionConfig(PretrainedConfig):
+    model_type = "chexagent_vision_model"
+
+    def __init__(
+            self,
+            hidden_size=1408,
+            intermediate_size=6144,
+            num_hidden_layers=39,
+            num_attention_heads=16,
+            image_size=224,
+            patch_size=14,
+            hidden_act="gelu",
+            layer_norm_eps=1e-6,
+            attention_dropout=0.0,
+            initializer_range=1e-10,
+            qkv_bias=True,
+            **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.patch_size = patch_size
+        self.image_size = image_size
+        self.initializer_range = initializer_range
+        self.attention_dropout = attention_dropout
+        self.layer_norm_eps = layer_norm_eps
+        self.hidden_act = hidden_act
+        self.qkv_bias = qkv_bias
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
+        cls._set_token_in_kwargs(kwargs)
+
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        if config_dict.get("model_type") == "chexagent":
+            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)
+
+
+class CheXagentQFormerConfig(PretrainedConfig):
+    model_type = "chexagent_qformer"
+
+    def __init__(
+            self,
+            vocab_size=30522,
+            hidden_size=768,
+            num_hidden_layers=12,
+            num_attention_heads=12,
+            intermediate_size=3072,
+            hidden_act="gelu",
+            hidden_dropout_prob=0.1,
+            attention_probs_dropout_prob=0.1,
+            max_position_embeddings=512,
+            initializer_range=0.02,
+            layer_norm_eps=1e-12,
+            pad_token_id=0,
+            position_embedding_type="absolute",
+            cross_attention_frequency=2,
+            encoder_hidden_size=1408,
+            **kwargs,
+    ):
+        super().__init__(pad_token_id=pad_token_id, **kwargs)
+
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.hidden_act = hidden_act
+        self.intermediate_size = intermediate_size
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.initializer_range = initializer_range
+        self.layer_norm_eps = layer_norm_eps
+        self.position_embedding_type = position_embedding_type
+        self.cross_attention_frequency = cross_attention_frequency
+        self.encoder_hidden_size = encoder_hidden_size
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path: Union[str, os.PathLike], **kwargs) -> "PretrainedConfig":
+        cls._set_token_in_kwargs(kwargs)
+
+        config_dict, kwargs = cls.get_config_dict(pretrained_model_name_or_path, **kwargs)
+
+        if config_dict.get("model_type") == "chexagent":
+            config_dict = config_dict["qformer_config"]
+
+        if "model_type" in config_dict and hasattr(cls, "model_type") and config_dict["model_type"] != cls.model_type:
+            logger.warning(
+                f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
+                f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."
+            )
+
+        return cls.from_dict(config_dict, **kwargs)
+
+
+class CheXagentConfig(PretrainedConfig):
+    model_type = "chexagent"
+
+    def __init__(
+            self, vision_config=None, qformer_config=None, text_config=None, num_query_tokens=128,
+            num_max_images=2, **kwargs
+    ):
+        super().__init__(**kwargs)
+
+        if vision_config is None:
+            vision_config = {}
+
+        if qformer_config is None:
+            qformer_config = {}
+
+        if text_config is None:
+            text_config = {}
+
+        self.vision_config = CheXagentVisionConfig(**vision_config)
+        self.qformer_config = CheXagentQFormerConfig(**qformer_config)
+        text_model_type = text_config["model_type"] if "model_type" in text_config else "opt"
+        self.text_config = CONFIG_MAPPING[text_model_type](**text_config)
+
+        self.tie_word_embeddings = self.text_config.tie_word_embeddings
+        self.is_encoder_decoder = self.text_config.is_encoder_decoder
+
+        self.num_query_tokens = num_query_tokens
+        self.qformer_config.encoder_hidden_size = self.vision_config.hidden_size
+        self.use_decoder_only_language_model = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
+        self.initializer_factor = 1.0
+        self.initializer_range = 0.02
+        self.num_max_images = num_max_images
+
+    @classmethod
+    def from_vision_qformer_text_configs(
+            cls,
+            vision_config: CheXagentVisionConfig,
+            qformer_config: CheXagentQFormerConfig,
+            text_config: PretrainedConfig,
+            **kwargs,
+    ):
+        return cls(
+            vision_config=vision_config.to_dict(),
+            qformer_config=qformer_config.to_dict(),
+            text_config=text_config.to_dict(),
+            **kwargs,
+        )

generation_config.json

@@ -0,0 +1,14 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "do_sample": false,
+  "num_beams": 5,
+  "min_length": 0,
+  "max_length": 512,
+  "top_p": 1.0,
+  "repetition_penalty": 1.0,
+  "length_penalty": 1.0,
+  "temperature": 1,
+  "transformers_version": "4.35.2"
+}

model-00001-of-00007.safetensors

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

model-00002-of-00007.safetensors

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

model-00003-of-00007.safetensors

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

model-00004-of-00007.safetensors

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

model-00005-of-00007.safetensors

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

model-00006-of-00007.safetensors

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

model-00007-of-00007.safetensors

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

model.safetensors.index.json

@@ -0,0 +1,1041 @@
+{
+  "metadata": {
+    "total_size": 33449606656
+  },
+  "weight_map": {
+    "language_model.lm_head.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.embed_tokens.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.0.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.1.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.10.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.10.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.10.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.10.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.10.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.10.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.10.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.10.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.10.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.11.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.11.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.12.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.13.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.14.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.input_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.mlp.down_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.mlp.up_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.post_attention_layernorm.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.15.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.16.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.16.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.16.mlp.gate_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.16.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.16.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.16.self_attn.k_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.16.self_attn.o_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.16.self_attn.q_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.16.self_attn.v_proj.weight": "model-00004-of-00007.safetensors",
+    "language_model.model.layers.17.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.17.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.18.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.19.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.2.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.2.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.20.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.20.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.input_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.mlp.down_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.mlp.gate_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.mlp.up_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.post_attention_layernorm.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.21.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.22.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.22.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.22.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.22.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.22.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.22.self_attn.k_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.22.self_attn.o_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.22.self_attn.q_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.22.self_attn.v_proj.weight": "model-00005-of-00007.safetensors",
+    "language_model.model.layers.23.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.23.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.24.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.25.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.input_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.mlp.down_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.post_attention_layernorm.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.26.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.27.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.27.mlp.gate_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.mlp.up_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.27.self_attn.k_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.self_attn.o_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.self_attn.q_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.27.self_attn.v_proj.weight": "model-00006-of-00007.safetensors",
+    "language_model.model.layers.28.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.28.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.29.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.3.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.3.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.30.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.30.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.input_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.mlp.down_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.mlp.gate_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.mlp.up_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.post_attention_layernorm.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.self_attn.k_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.self_attn.o_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.self_attn.q_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.31.self_attn.v_proj.weight": "model-00007-of-00007.safetensors",
+    "language_model.model.layers.4.input_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.mlp.down_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.mlp.gate_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.mlp.up_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.post_attention_layernorm.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.self_attn.o_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.4.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.5.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.self_attn.k_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.5.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.5.self_attn.q_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.5.self_attn.v_proj.weight": "model-00002-of-00007.safetensors",
+    "language_model.model.layers.6.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.6.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.7.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.8.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.input_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.mlp.down_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.mlp.gate_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.mlp.up_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.post_attention_layernorm.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.self_attn.k_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.self_attn.o_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.self_attn.q_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.layers.9.self_attn.v_proj.weight": "model-00003-of-00007.safetensors",
+    "language_model.model.norm.weight": "model-00007-of-00007.safetensors",
+    "language_projection.bias": "model-00001-of-00007.safetensors",
+    "language_projection.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.0.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.1.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.10.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.11.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.2.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.3.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.4.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.5.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.6.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.7.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.crossattention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.8.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.key.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.key.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.query.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.query.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.value.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.attention.value.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.output.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.output.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.output.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.attention.output.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.intermediate_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.intermediate_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.output_query.LayerNorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.output_query.LayerNorm.weight": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.output_query.dense.bias": "model-00001-of-00007.safetensors",
+    "qformer.encoder.layer.9.output_query.dense.weight": "model-00001-of-00007.safetensors",
+    "qformer.layernorm.bias": "model-00001-of-00007.safetensors",
+    "qformer.layernorm.weight": "model-00001-of-00007.safetensors",
+    "query_tokens": "model-00001-of-00007.safetensors",
+    "vision_model.embeddings.class_embedding": "model-00001-of-00007.safetensors",
+    "vision_model.embeddings.patch_embedding.bias": "model-00001-of-00007.safetensors",
+    "vision_model.embeddings.patch_embedding.weight": "model-00001-of-00007.safetensors",
+    "vision_model.embeddings.position_embedding": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.0.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.1.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.10.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.11.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.12.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.13.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.14.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.15.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.16.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.17.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.18.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.19.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.2.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.20.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.21.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.22.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.23.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.24.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.25.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.26.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.27.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.28.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.29.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.3.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.30.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.31.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.32.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.33.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.34.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.35.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.36.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.37.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.38.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.39.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.4.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.5.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.6.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.7.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.8.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.layer_norm1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.layer_norm1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.layer_norm2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.layer_norm2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.mlp.fc1.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.mlp.fc1.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.mlp.fc2.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.mlp.fc2.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.self_attn.projection.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.self_attn.projection.weight": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.self_attn.qkv.bias": "model-00001-of-00007.safetensors",
+    "vision_model.encoder.layers.9.self_attn.qkv.weight": "model-00001-of-00007.safetensors",
+    "vision_model.post_layernorm.bias": "model-00001-of-00007.safetensors",
+    "vision_model.post_layernorm.weight": "model-00001-of-00007.safetensors"
+  }
+}

modeling_chexagent.py

@@ -0,0 +1,1300 @@
+# coding=utf-8
+# Copyright 2023 The CheXagent Authors, The Salesforce Authors 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.
+
+import math
+from dataclasses import dataclass
+from typing import Any, Optional, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from einops import rearrange
+from torch import nn
+from torch.nn import CrossEntropyLoss
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPastAndCrossAttentions,
+    BaseModelOutputWithPooling,
+    BaseModelOutputWithPoolingAndCrossAttentions,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.models.auto import AutoModelForCausalLM, AutoModelForSeq2SeqLM
+from transformers.pytorch_utils import apply_chunking_to_forward, find_pruneable_heads_and_indices, prune_linear_layer
+from transformers.utils import ModelOutput, logging
+
+from .configuration_chexagent import CheXagentConfig, CheXagentQFormerConfig, CheXagentVisionConfig
+
+logger = logging.get_logger(__name__)
+
+
+@dataclass
+class CheXagentForConditionalGenerationModelOutput(ModelOutput):
+    loss: Optional[Tuple[torch.FloatTensor]] = None
+    logits: Optional[Tuple[torch.FloatTensor]] = None
+    vision_outputs: Optional[torch.FloatTensor] = None
+    qformer_outputs: Optional[Tuple[torch.FloatTensor]] = None
+    language_model_outputs: Optional[Tuple[torch.FloatTensor]] = None
+
+    def to_tuple(self) -> Tuple[Any]:
+        return tuple(
+            self[k]
+            if k not in ["vision_outputs", "qformer_outputs", "language_model_outputs"]
+            else getattr(self, k).to_tuple()
+            for k in self.keys()
+        )
+
+
+class CheXagentVisionEmbeddings(nn.Module):
+    def __init__(self, config: CheXagentVisionConfig):
+        super().__init__()
+        self.config = config
+        self.embed_dim = config.hidden_size
+        self.image_size = config.image_size
+        self.patch_size = config.patch_size
+
+        self.class_embedding = nn.Parameter(torch.randn(1, 1, self.embed_dim))
+
+        self.patch_embedding = nn.Conv2d(
+            in_channels=3, out_channels=self.embed_dim, kernel_size=self.patch_size, stride=self.patch_size
+        )
+
+        self.num_patches = (self.image_size // self.patch_size) ** 2
+        self.num_positions = self.num_patches + 1
+
+        self.position_embedding = nn.Parameter(torch.randn(1, self.num_positions, self.embed_dim))
+
+    def forward(self, pixel_values: torch.FloatTensor) -> torch.Tensor:
+        batch_size = pixel_values.shape[0]
+        target_dtype = self.patch_embedding.weight.dtype
+        patch_embeds = self.patch_embedding(pixel_values.to(dtype=target_dtype))  # shape = [*, width, grid, grid]
+        patch_embeds = patch_embeds.flatten(2).transpose(1, 2)
+
+        class_embeds = self.class_embedding.expand(batch_size, 1, -1).to(target_dtype)
+        embeddings = torch.cat([class_embeds, patch_embeds], dim=1)
+        embeddings = embeddings + self.position_embedding[:, : embeddings.size(1), :].to(target_dtype)
+        return embeddings
+
+
+class CheXagentAttention(nn.Module):
+    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 = nn.Dropout(config.attention_dropout)
+
+        # small tweak here compared to CLIP, no bias here
+        self.qkv = nn.Linear(self.embed_dim, 3 * self.embed_dim, bias=False)
+
+        if config.qkv_bias:
+            q_bias = nn.Parameter(torch.zeros(self.embed_dim))
+            v_bias = nn.Parameter(torch.zeros(self.embed_dim))
+        else:
+            q_bias = None
+            v_bias = None
+
+        if q_bias is not None:
+            qkv_bias = torch.cat((q_bias, torch.zeros_like(v_bias, requires_grad=False), v_bias))
+            self.qkv.bias = nn.Parameter(qkv_bias)
+
+        self.projection = nn.Linear(self.embed_dim, self.embed_dim)
+
+    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
+        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            head_mask: Optional[torch.Tensor] = None,
+            output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
+        bsz, tgt_len, embed_dim = hidden_states.size()
+
+        mixed_qkv = self.qkv(hidden_states)
+
+        mixed_qkv = mixed_qkv.reshape(bsz, tgt_len, 3, self.num_heads, embed_dim // self.num_heads).permute(
+            2, 0, 3, 1, 4
+        )
+        query_states, key_states, value_states = mixed_qkv[0], mixed_qkv[1], mixed_qkv[2]
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_states, key_states.transpose(-1, -2))
+
+        attention_scores = attention_scores * self.scale
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_states).permute(0, 2, 1, 3)
+
+        new_context_layer_shape = context_layer.size()[:-2] + (self.embed_dim,)
+        context_layer = context_layer.reshape(new_context_layer_shape)
+
+        output = self.projection(context_layer)
+
+        outputs = (output, attention_probs) if output_attentions else (output, None)
+
+        return outputs
+
+
+class CheXagentMLP(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
+
+
+class CheXagentEncoderLayer(nn.Module):
+    def __init__(self, config: CheXagentConfig):
+        super().__init__()
+        self.embed_dim = config.hidden_size
+        self.self_attn = CheXagentAttention(config)
+        self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
+        self.mlp = CheXagentMLP(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]:
+        residual = hidden_states
+        hidden_states = self.layer_norm1(hidden_states)
+        hidden_states, attn_weights = self.self_attn(
+            hidden_states=hidden_states,
+            head_mask=attention_mask,
+            output_attentions=output_attentions,
+        )
+        hidden_states = hidden_states + residual
+        residual = hidden_states
+        hidden_states = self.layer_norm2(hidden_states)
+        hidden_states = self.mlp(hidden_states)
+
+        hidden_states = hidden_states + residual
+
+        outputs = (hidden_states,)
+
+        if output_attentions:
+            outputs += (attn_weights,)
+
+        return outputs
+
+
+class CheXagentPreTrainedModel(PreTrainedModel):
+    config_class = CheXagentConfig
+    base_model_prefix = "chexagent"
+    supports_gradient_checkpointing = True
+    _no_split_modules = [
+        "CheXagentQFormerEmbeddings",
+        "CheXagentAttention",
+        "CheXagentQFormerMultiHeadAttention",
+        "CheXagentQFormerSelfOutput",
+    ]
+    _keep_in_fp32_modules = []
+
+    def _init_weights(self, module):
+        """Initialize the weights"""
+        factor = self.config.initializer_range
+        if isinstance(module, nn.Conv2d) or isinstance(module, nn.Embedding) or isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=factor)
+            if hasattr(module, "bias") and module.bias is not None:
+                module.bias.data.zero_()
+
+        if isinstance(module, CheXagentVisionEmbeddings):
+            if hasattr(self.config, "vision_config"):
+                factor = self.config.vision_config.initializer_range
+            nn.init.trunc_normal_(module.position_embedding, mean=0.0, std=factor)
+            nn.init.trunc_normal_(module.class_embedding, mean=0.0, std=factor)
+
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        elif isinstance(module, nn.Linear) and module.bias is not None:
+            module.bias.data.zero_()
+
+
+class CheXagentEncoder(nn.Module):
+    def __init__(self, config: CheXagentConfig):
+        super().__init__()
+        self.config = config
+        self.layers = nn.ModuleList([CheXagentEncoderLayer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    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]:
+        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 idx, encoder_layer in enumerate(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
+        )
+
+
+class CheXagentVisionModel(CheXagentPreTrainedModel):
+    main_input_name = "pixel_values"
+    config_class = CheXagentVisionConfig
+
+    def __init__(self, config: CheXagentVisionConfig):
+        super().__init__(config)
+        self.config = config
+        embed_dim = config.hidden_size
+
+        self.embeddings = CheXagentVisionEmbeddings(config)
+        self.encoder = CheXagentEncoder(config)
+        self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
+
+        self.post_init()
+
+    def forward(
+            self,
+            pixel_values: Optional[torch.FloatTensor] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        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
+
+        if pixel_values is None:
+            raise ValueError("You have to specify pixel_values")
+        hidden_states = self.embeddings(pixel_values)
+
+        encoder_outputs = self.encoder(
+            inputs_embeds=hidden_states,
+            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)
+
+        pooled_output = last_hidden_state[:, 0, :]
+        pooled_output = self.post_layernorm(pooled_output)
+
+        if not return_dict:
+            return (last_hidden_state, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPooling(
+            last_hidden_state=last_hidden_state,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+    def get_input_embeddings(self):
+        return self.embeddings
+
+
+class CheXagentQFormerMultiHeadAttention(nn.Module):
+    def __init__(self, config, is_cross_attention=False):
+        super().__init__()
+        self.config = config
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention heads (%d)"
+                % (config.hidden_size, config.num_attention_heads)
+            )
+
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        if is_cross_attention:
+            self.key = nn.Linear(config.encoder_hidden_size, self.all_head_size)
+            self.value = nn.Linear(config.encoder_hidden_size, self.all_head_size)
+        else:
+            self.key = nn.Linear(config.hidden_size, self.all_head_size)
+            self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            self.max_position_embeddings = config.max_position_embeddings
+            self.distance_embedding = nn.Embedding(2 * config.max_position_embeddings - 1, self.attention_head_size)
+        self.save_attention = False
+
+    def save_attn_gradients(self, attn_gradients):
+        self.attn_gradients = attn_gradients
+
+    def get_attn_gradients(self):
+        return self.attn_gradients
+
+    def save_attention_map(self, attention_map):
+        self.attention_map = attention_map
+
+    def get_attention_map(self):
+        return self.attention_map
+
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+            self,
+            hidden_states,
+            attention_mask=None,
+            head_mask=None,
+            encoder_hidden_states=None,
+            encoder_attention_mask=None,
+            past_key_value=None,
+            output_attentions=False,
+    ):
+        # If this is instantiated as a cross-attention module, the keys
+        # and values come from an encoder; the attention mask needs to be
+        # such that the encoder's padding tokens are not attended to.
+        is_cross_attention = encoder_hidden_states is not None
+
+        if is_cross_attention:
+            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
+            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
+            attention_mask = encoder_attention_mask
+        elif past_key_value is not None:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
+            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
+        else:
+            key_layer = self.transpose_for_scores(self.key(hidden_states))
+            value_layer = self.transpose_for_scores(self.value(hidden_states))
+
+        mixed_query_layer = self.query(hidden_states)
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        past_key_value = (key_layer, value_layer)
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+        if self.position_embedding_type == "relative_key" or self.position_embedding_type == "relative_key_query":
+            seq_length = hidden_states.size()[1]
+            position_ids_l = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(-1, 1)
+            position_ids_r = torch.arange(seq_length, dtype=torch.long, device=hidden_states.device).view(1, -1)
+            distance = position_ids_l - position_ids_r
+            positional_embedding = self.distance_embedding(distance + self.max_position_embeddings - 1)
+            positional_embedding = positional_embedding.to(dtype=query_layer.dtype)  # fp16 compatibility
+
+            if self.position_embedding_type == "relative_key":
+                relative_position_scores = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores
+            elif self.position_embedding_type == "relative_key_query":
+                relative_position_scores_query = torch.einsum("bhld,lrd->bhlr", query_layer, positional_embedding)
+                relative_position_scores_key = torch.einsum("bhrd,lrd->bhlr", key_layer, positional_embedding)
+                attention_scores = attention_scores + relative_position_scores_query + relative_position_scores_key
+
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+
+        if attention_mask is not None:
+            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+
+        if is_cross_attention and self.save_attention:
+            self.save_attention_map(attention_probs)
+            attention_probs.register_hook(self.save_attn_gradients)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs_dropped = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs_dropped = attention_probs_dropped * head_mask
+
+        context_layer = torch.matmul(attention_probs_dropped, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        outputs = outputs + (past_key_value,)
+        return outputs
+
+
+class CheXagentQFormerSelfOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class CheXagentQFormerAttention(nn.Module):
+    def __init__(self, config, is_cross_attention=False):
+        super().__init__()
+        self.attention = CheXagentQFormerMultiHeadAttention(config, is_cross_attention)
+        self.output = CheXagentQFormerSelfOutput(config)
+        self.pruned_heads = set()
+
+    def prune_heads(self, heads):
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.attention.num_attention_heads, self.attention.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.attention.query = prune_linear_layer(self.attention.query, index)
+        self.attention.key = prune_linear_layer(self.attention.key, index)
+        self.attention.value = prune_linear_layer(self.attention.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.attention.num_attention_heads = self.attention.num_attention_heads - len(heads)
+        self.attention.all_head_size = self.attention.attention_head_size * self.attention.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+            self,
+            hidden_states: torch.Tensor,
+            attention_mask: Optional[torch.FloatTensor] = None,
+            head_mask: Optional[torch.FloatTensor] = None,
+            encoder_hidden_states: Optional[torch.FloatTensor] = None,
+            encoder_attention_mask: Optional[torch.FloatTensor] = None,
+            past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+            output_attentions: Optional[bool] = False,
+    ) -> Tuple[torch.Tensor]:
+        self_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            encoder_hidden_states,
+            encoder_attention_mask,
+            past_key_value,
+            output_attentions,
+        )
+        attention_output = self.output(self_outputs[0], hidden_states)
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class CheXagentQFormerIntermediate(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
+        if isinstance(config.hidden_act, str):
+            self.intermediate_act_fn = ACT2FN[config.hidden_act]
+        else:
+            self.intermediate_act_fn = config.hidden_act
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+
+class CheXagentQFormerOutput(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class CheXagentQFormerLayer(nn.Module):
+    def __init__(self, config, layer_idx):
+        super().__init__()
+        self.chunk_size_feed_forward = config.chunk_size_feed_forward
+        self.seq_len_dim = 1
+        self.attention = CheXagentQFormerAttention(config)
+
+        self.layer_idx = layer_idx
+
+        if layer_idx % config.cross_attention_frequency == 0:
+            self.crossattention = CheXagentQFormerAttention(config, is_cross_attention=True)
+            self.has_cross_attention = True
+        else:
+            self.has_cross_attention = False
+
+        self.intermediate_query = CheXagentQFormerIntermediate(config)
+        self.output_query = CheXagentQFormerOutput(config)
+
+    def forward(
+            self,
+            hidden_states,
+            attention_mask=None,
+            head_mask=None,
+            encoder_hidden_states=None,
+            encoder_attention_mask=None,
+            past_key_value=None,
+            output_attentions=False,
+            query_length=0,
+    ):
+        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
+        self_attn_past_key_value = past_key_value[:2] if past_key_value is not None else None
+        self_attention_outputs = self.attention(
+            hidden_states,
+            attention_mask,
+            head_mask,
+            output_attentions=output_attentions,
+            past_key_value=self_attn_past_key_value,
+        )
+        attention_output = self_attention_outputs[0]
+        outputs = self_attention_outputs[1:-1]
+
+        present_key_value = self_attention_outputs[-1]
+
+        if query_length > 0:
+            query_attention_output = attention_output[:, :query_length, :]
+
+            if self.has_cross_attention:
+                if encoder_hidden_states is None:
+                    raise ValueError("encoder_hidden_states must be given for cross-attention layers")
+                cross_attention_outputs = self.crossattention(
+                    query_attention_output,
+                    attention_mask,
+                    head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    output_attentions=output_attentions,
+                )
+                query_attention_output = cross_attention_outputs[0]
+                # add cross attentions if we output attention weights
+                outputs = outputs + cross_attention_outputs[1:-1]
+
+            layer_output = apply_chunking_to_forward(
+                self.feed_forward_chunk_query,
+                self.chunk_size_feed_forward,
+                self.seq_len_dim,
+                query_attention_output,
+            )
+
+            if attention_output.shape[1] > query_length:
+                layer_output_text = apply_chunking_to_forward(
+                    self.feed_forward_chunk,
+                    self.chunk_size_feed_forward,
+                    self.seq_len_dim,
+                    attention_output[:, query_length:, :],
+                )
+                layer_output = torch.cat([layer_output, layer_output_text], dim=1)
+        else:
+            layer_output = apply_chunking_to_forward(
+                self.feed_forward_chunk,
+                self.chunk_size_feed_forward,
+                self.seq_len_dim,
+                attention_output,
+            )
+        outputs = (layer_output,) + outputs
+
+        outputs = outputs + (present_key_value,)
+
+        return outputs
+
+    def feed_forward_chunk(self, attention_output):
+        intermediate_output = self.intermediate(attention_output)
+        layer_output = self.output(intermediate_output, attention_output)
+        return layer_output
+
+    def feed_forward_chunk_query(self, attention_output):
+        intermediate_output = self.intermediate_query(attention_output)
+        layer_output = self.output_query(intermediate_output, attention_output)
+        return layer_output
+
+
+class CheXagentQFormerEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList(
+            [CheXagentQFormerLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self.gradient_checkpointing = False
+
+    def forward(
+            self,
+            hidden_states,
+            attention_mask=None,
+            head_mask=None,
+            encoder_hidden_states=None,
+            encoder_attention_mask=None,
+            past_key_values=None,
+            use_cache=None,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+            query_length=0,
+    ):
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions else None
+
+        next_decoder_cache = () if use_cache else None
+
+        for i in range(self.config.num_hidden_layers):
+            layer_module = self.layer[i]
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+            past_key_value = past_key_values[i] if past_key_values is not None else None
+
+            if getattr(self.config, "gradient_checkpointing", False) and self.training:
+                if use_cache:
+                    logger.warning(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+                layer_outputs = self._gradient_checkpointing_func(
+                    layer_module.__call__,
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    past_key_value,
+                    output_attentions,
+                    query_length,
+                )
+
+            hidden_states = layer_outputs[0]
+            if use_cache:
+                next_decoder_cache += (layer_outputs[-1],)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+                if layer_module.has_cross_attention:
+                    all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                    all_cross_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=next_decoder_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+class CheXagentQFormerEmbeddings(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+
+        self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
+        self.register_buffer(
+            "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)), persistent=False
+        )
+        self.position_embedding_type = getattr(config, "position_embedding_type", "absolute")
+
+        self.config = config
+
+    def forward(
+            self,
+            input_ids=None,
+            position_ids=None,
+            query_embeds=None,
+            past_key_values_length=0,
+    ):
+        if input_ids is not None:
+            seq_length = input_ids.size()[1]
+        else:
+            seq_length = 0
+
+        if position_ids is None:
+            position_ids = self.position_ids[:, past_key_values_length: seq_length + past_key_values_length].clone()
+
+        if input_ids is not None:
+            embeddings = self.word_embeddings(input_ids)
+            if self.position_embedding_type == "absolute":
+                position_embeddings = self.position_embeddings(position_ids.to(embeddings.device))
+                embeddings = embeddings + position_embeddings
+
+            if query_embeds is not None:
+                embeddings = torch.cat((query_embeds, embeddings), dim=1)
+        else:
+            embeddings = query_embeds
+
+        embeddings = embeddings.to(self.layernorm.weight.dtype)
+        embeddings = self.layernorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        return embeddings
+
+
+class CheXagentQFormerEncoder(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList(
+            [CheXagentQFormerLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)]
+        )
+        self.gradient_checkpointing = False
+
+    def forward(
+            self,
+            hidden_states,
+            attention_mask=None,
+            head_mask=None,
+            encoder_hidden_states=None,
+            encoder_attention_mask=None,
+            past_key_values=None,
+            use_cache=None,
+            output_attentions=False,
+            output_hidden_states=False,
+            return_dict=True,
+            query_length=0,
+    ):
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+        all_cross_attentions = () if output_attentions else None
+
+        next_decoder_cache = () if use_cache else None
+
+        for i in range(self.config.num_hidden_layers):
+            layer_module = self.layer[i]
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+            past_key_value = past_key_values[i] if past_key_values is not None else None
+
+            if getattr(self.config, "gradient_checkpointing", False) and self.training:
+                if use_cache:
+                    logger.warning(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+                layer_outputs = self._gradient_checkpointing_func(
+                    layer_module.__call__,
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                )
+            else:
+                layer_outputs = layer_module(
+                    hidden_states,
+                    attention_mask,
+                    layer_head_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    past_key_value,
+                    output_attentions,
+                    query_length,
+                )
+
+            hidden_states = layer_outputs[0]
+            if use_cache:
+                next_decoder_cache += (layer_outputs[-1],)
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+                if layer_module.has_cross_attention:
+                    all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(
+                v
+                for v in [
+                    hidden_states,
+                    next_decoder_cache,
+                    all_hidden_states,
+                    all_self_attentions,
+                    all_cross_attentions,
+                ]
+                if v is not None
+            )
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=next_decoder_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+            cross_attentions=all_cross_attentions,
+        )
+
+
+class CheXagentQFormerModel(CheXagentPreTrainedModel):
+    def __init__(self, config: CheXagentQFormerConfig):
+        super().__init__(config)
+        self.config = config
+
+        self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+        self.encoder = CheXagentQFormerEncoder(config)
+
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.embeddings.word_embeddings
+
+    def set_input_embeddings(self, value):
+        self.embeddings.word_embeddings = value
+
+    def _prune_heads(self, heads_to_prune):
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    def get_extended_attention_mask(
+            self,
+            attention_mask: torch.Tensor,
+            input_shape: Tuple[int],
+            device: torch.device,
+            has_query: bool = False,
+    ) -> torch.Tensor:
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        if attention_mask.dim() == 3:
+            extended_attention_mask = attention_mask[:, None, :, :]
+        elif attention_mask.dim() == 2:
+            # Provided a padding mask of dimensions [batch_size, seq_length]
+            # - the model is an encoder, so make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length]
+            extended_attention_mask = attention_mask[:, None, None, :]
+        else:
+            raise ValueError(
+                "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(
+                    input_shape, attention_mask.shape
+                )
+            )
+
+        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
+        # masked positions, this operation will create a tensor which is 0.0 for
+        # positions we want to attend and -10000.0 for masked positions.
+        # Since we are adding it to the raw scores before the softmax, this is
+        # effectively the same as removing these entirely.
+        extended_attention_mask = extended_attention_mask.to(dtype=self.dtype)  # fp16 compatibility
+        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
+        return extended_attention_mask
+
+    def forward(
+            self,
+            query_embeds: torch.FloatTensor,
+            attention_mask: Optional[torch.FloatTensor] = None,
+            head_mask: Optional[torch.FloatTensor] = None,
+            encoder_hidden_states: Optional[torch.FloatTensor] = None,
+            encoder_attention_mask: Optional[torch.FloatTensor] = None,
+            past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
+        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
+
+        # past_key_values_length
+        past_key_values_length = (
+            past_key_values[0][0].shape[2] - self.config.query_length if past_key_values is not None else 0
+        )
+
+        query_length = query_embeds.shape[1] if query_embeds is not None else 0
+
+        embedding_output = self.layernorm(query_embeds)
+        embedding_output = self.dropout(embedding_output)
+
+        input_shape = embedding_output.size()[:-1]
+        batch_size, seq_length = input_shape
+        device = embedding_output.device
+
+        if attention_mask is None:
+            attention_mask = torch.ones(((batch_size, seq_length + past_key_values_length)), device=device)
+
+        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
+        # ourselves in which case we just need to make it broadcastable to all heads.
+        extended_attention_mask = self.get_extended_attention_mask(attention_mask, input_shape, device)
+
+        # If a 2D or 3D attention mask is provided for the cross-attention
+        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
+        if encoder_hidden_states is not None:
+            if type(encoder_hidden_states) == list:
+                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[0].size()
+            else:
+                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states.size()
+            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
+
+            if type(encoder_attention_mask) == list:
+                encoder_extended_attention_mask = [self.invert_attention_mask(mask) for mask in encoder_attention_mask]
+            elif encoder_attention_mask is None:
+                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
+                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+            else:
+                encoder_extended_attention_mask = self.invert_attention_mask(encoder_attention_mask)
+        else:
+            encoder_extended_attention_mask = None
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        encoder_outputs = self.encoder(
+            embedding_output,
+            attention_mask=extended_attention_mask,
+            head_mask=head_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_extended_attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            query_length=query_length,
+        )
+        sequence_output = encoder_outputs[0]
+        pooled_output = sequence_output[:, 0, :]
+
+        if not return_dict:
+            return (sequence_output, pooled_output) + encoder_outputs[1:]
+
+        return BaseModelOutputWithPoolingAndCrossAttentions(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            past_key_values=encoder_outputs.past_key_values,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+            cross_attentions=encoder_outputs.cross_attentions,
+        )
+
+
+class CheXagentForConditionalGeneration(CheXagentPreTrainedModel):
+    config_class = CheXagentConfig
+    main_input_name = "pixel_values"
+
+    def __init__(self, config: CheXagentConfig):
+        super().__init__(config)
+
+        self.vision_model = CheXagentVisionModel(config.vision_config)
+
+        self.query_tokens = nn.Parameter(torch.zeros(1, config.num_query_tokens, config.qformer_config.hidden_size))
+        self.qformer = CheXagentQFormerModel(config.qformer_config)
+
+        self.language_projection = nn.Linear(config.qformer_config.hidden_size, config.text_config.hidden_size)
+        if config.use_decoder_only_language_model:
+            language_model = AutoModelForCausalLM.from_config(config.text_config)
+        else:
+            language_model = AutoModelForSeq2SeqLM.from_config(config.text_config)
+
+        # Update _tied_weights_keys using the base model used.
+        if language_model._tied_weights_keys is not None:
+            self._tied_weights_keys = [f"language_model.{k}" for k in language_model._tied_weights_keys]
+
+        self.language_model = language_model
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.language_model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.language_model.set_input_embeddings(value)
+
+    def set_output_embeddings(self, new_embeddings):
+        self.language_model.set_output_embeddings(new_embeddings)
+
+    def get_output_embeddings(self) -> nn.Module:
+        return self.language_model.get_output_embeddings()
+
+    def get_encoder(self):
+        return self.language_model.get_encoder()
+
+    def get_decoder(self):
+        return self.language_model.get_decoder()
+
+    def _tie_weights(self):
+        if not self.config.use_decoder_only_language_model:
+            self.language_model.encoder.embed_tokens = self.language_model.shared
+            self.language_model.decoder.embed_tokens = self.language_model.shared
+
+    def _preprocess_accelerate(self):
+        hf_device_map = self.hf_device_map
+        if len(hf_device_map) > 1 and "language_model" not in hf_device_map and torch.cuda.device_count() > 1:
+            # warn users about unexpected behavior when using multi-GPU + BLIP-2 + `accelerate`.
+            logger.warning(
+                "The `language_model` is not in the `hf_device_map` dictionary and you are running your script"
+                " in a multi-GPU environment. this may lead to unexpected behavior when using `accelerate`."
+                " Please pass a `device_map` that contains `language_model` to remove this warning."
+                " Please refer to https://github.com/huggingface/blog/blob/main/accelerate-large-models.md for"
+                " more details on creating a `device_map` for large models.",
+            )
+        if hasattr(self.language_model, "_hf_hook"):
+            self.language_model._hf_hook.io_same_device = True  # For `generate` compatibility
+
+    def forward(
+            self,
+            pixel_values: torch.FloatTensor = None,
+            input_ids: torch.FloatTensor = None,
+            attention_mask: Optional[torch.LongTensor] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            labels: Optional[torch.LongTensor] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CheXagentForConditionalGenerationModelOutput]:
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        vision_outputs, query_outputs = None, None
+        if pixel_values is not None:
+            # step 1: forward the images through the vision encoder,
+            # to get image embeddings of shape (batch_size, seq_len, hidden_size)
+            image_mask = pixel_values.sum(dim=(2, 3, 4)) != 0
+            vision_outputs = self.vision_model(
+                pixel_values=pixel_values[image_mask],
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+            )
+            tmp = vision_outputs[0]
+            image_embeds = tmp.new_zeros((*image_mask.shape, *tmp.shape[1:]))
+            image_embeds[image_mask] = tmp
+
+            # step 2: forward the query tokens through the QFormer, using the image embeddings for cross-attention
+            image_attention_mask = torch.zeros(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)
+            image_attention_mask[image_mask] = 1
+
+            image_embeds = rearrange(image_embeds, "b i n d -> b (i n) d")
+            image_attention_mask = rearrange(image_attention_mask, "b i n -> b (i n)")
+            query_tokens = self.query_tokens.expand(image_embeds.shape[0], -1, -1)
+            query_outputs = self.qformer(
+                query_embeds=query_tokens,
+                encoder_hidden_states=image_embeds,
+                encoder_attention_mask=image_attention_mask,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+            )
+            query_output = query_outputs[0]
+
+            # step 3: project vision to language
+            input_vis = self.language_projection(query_output)
+            vis_atts = torch.ones(input_vis.size()[:-1], dtype=torch.long, device=input_vis.device)
+
+        # step 4: get the embeddings of the prompt
+        inputs_lang = self.language_model.get_input_embeddings()(input_ids)
+        lang_atts = attention_mask
+        if lang_atts is None:
+            lang_atts = torch.ones_like(input_ids)
+
+        # step 5: conditioned on the images and/or prompts
+        if pixel_values is not None:
+            inputs_embeds = torch.cat([input_vis, inputs_lang], dim=1)
+            attention_mask = torch.cat([vis_atts, lang_atts], dim=1)
+        else:
+            inputs_embeds = inputs_lang
+            attention_mask = lang_atts
+
+        outputs = self.language_model(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+        logits = outputs.logits if return_dict else outputs[0]
+
+        loss = None
+        # we compute the loss here since we need to take into account the sequence length of the query embeds
+        if labels is not None:
+            # make target
+            empty_labels = torch.ones(vis_atts.size(), dtype=torch.long, device=input_ids.device).fill_(-100)
+            labels = torch.cat([empty_labels, labels], dim=1)
+            labels = labels.to(logits.device)
+            logits = logits[:, -labels.size(1):, :]
+            # Shift so that tokens < n predict n
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous().to(logits.device)
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss(reduction="mean")
+            loss = loss_fct(shift_logits.view(-1, self.config.text_config.vocab_size), shift_labels.view(-1))
+
+        if not return_dict:
+            output = (logits, vision_outputs, query_outputs, outputs)
+            return ((loss,) + output) if loss is not None else output
+
+        return CheXagentForConditionalGenerationModelOutput(
+            loss=loss,
+            logits=logits,
+            vision_outputs=vision_outputs,
+            qformer_outputs=query_outputs,
+            language_model_outputs=outputs,
+        )
+
+    @torch.no_grad()
+    def generate(
+            self,
+            pixel_values: torch.FloatTensor = None,
+            input_ids: Optional[torch.LongTensor] = None,
+            attention_mask: Optional[torch.LongTensor] = None,
+            **generate_kwargs,
+    ) -> torch.LongTensor:
+        if hasattr(self, "hf_device_map"):
+            # preprocess for `accelerate`
+            self._preprocess_accelerate()
+
+        batch_size = pixel_values.shape[0] if pixel_values is not None else input_ids.shape[0]
+        if pixel_values is not None:
+            # step 1: forward the images through the vision encoder
+            image_mask = pixel_values.sum(dim=(2, 3, 4)) != 0
+            vision_outputs = self.vision_model(pixel_values[image_mask], return_dict=True)
+            tmp = vision_outputs[0]
+            image_embeds = tmp.new_zeros((*image_mask.shape, *tmp.shape[1:]))
+            image_embeds[image_mask] = tmp
+
+            # step 2: forward the query tokens through the QFormer, using the image embeddings for cross-attention
+            image_attention_mask = torch.zeros(image_embeds.size()[:-1], dtype=torch.long, device=image_embeds.device)
+            image_attention_mask[image_mask] = 1
+            image_embeds = rearrange(image_embeds, "b i n d -> b (i n) d")
+            image_attention_mask = rearrange(image_attention_mask, "b i n -> b (i n)")
+            query_tokens = self.query_tokens.expand(image_embeds.shape[0], -1, -1)
+            query_outputs = self.qformer(
+                query_embeds=query_tokens,
+                encoder_hidden_states=image_embeds,
+                encoder_attention_mask=image_attention_mask,
+                return_dict=True,
+            )
+            query_output = query_outputs.last_hidden_state
+
+            # step 3: project vision to language
+            input_vis = self.language_projection(query_output)
+            vis_atts = torch.ones(input_vis.size()[:-1], dtype=torch.long, device=input_vis.device)
+
+        # step 4: get the embeddings of the prompt
+        if input_ids is None:
+            input_ids = (
+                torch.LongTensor([[self.config.text_config.bos_token_id]])
+                .repeat(batch_size, 1)
+                .to(next(self.parameters()).device)
+            )
+        inputs_lang = self.language_model.get_input_embeddings()(input_ids)
+        lang_atts = attention_mask
+        if lang_atts is None:
+            lang_atts = torch.ones_like(input_ids)
+
+        # step 5: conditioned on the images and/or prompts
+        if pixel_values is not None:
+            inputs_embeds = torch.cat([input_vis, inputs_lang], dim=1)
+            attention_mask = torch.cat([vis_atts, lang_atts], dim=1)
+        else:
+            inputs_embeds = inputs_lang
+            attention_mask = lang_atts
+
+        outputs = self.language_model.generate(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            **generate_kwargs,
+        )
+        return outputs

preprocessor_config.json

@@ -0,0 +1,27 @@
+{
+  "do_convert_rgb": true,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.48145466,
+    0.4578275,
+    0.40821073
+  ],
+  "image_processor_type": "BlipImageProcessor",
+  "image_std": [
+    0.26862954,
+    0.26130258,
+    0.27577711
+  ],
+  "processor_class": "CheXagentProcessor",
+  "resample": 3,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 448,
+    "width": 448
+  },
+  "auto_map": {
+    "AutoProcessor": "processing_chexagent.CheXagentProcessor"
+  }
+}

processing_chexagent.py

@@ -0,0 +1,126 @@
+# coding=utf-8
+# Copyright 2023 The CheXagent Authors and The HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List, Optional, Union
+
+import torch
+from transformers.image_utils import ImageInput
+from transformers.processing_utils import ProcessorMixin
+from transformers.tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput
+from transformers.tokenization_utils_base import TruncationStrategy
+from transformers.utils import TensorType
+
+
+class CheXagentProcessor(ProcessorMixin):
+    attributes = ["image_processor", "tokenizer"]
+    image_processor_class = "BlipImageProcessor"
+    tokenizer_class = "AutoTokenizer"
+
+    def __init__(self, image_processor, tokenizer):
+        tokenizer.return_token_type_ids = False
+        super().__init__(image_processor, tokenizer)
+        self.current_processor = self.image_processor
+
+    def __call__(
+            self,
+            images: ImageInput = None,
+            text: Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None,
+            add_special_tokens: bool = True,
+            padding: Union[bool, str, PaddingStrategy] = False,
+            truncation: Union[bool, str, TruncationStrategy] = None,
+            max_length: Optional[int] = None,
+            stride: int = 0,
+            pad_to_multiple_of: Optional[int] = None,
+            return_attention_mask: Optional[bool] = None,
+            return_overflowing_tokens: bool = False,
+            return_special_tokens_mask: bool = False,
+            return_offsets_mapping: bool = False,
+            return_token_type_ids: bool = False,
+            return_length: bool = False,
+            verbose: bool = True,
+            return_tensors: Optional[Union[str, TensorType]] = None,
+            **kwargs,
+    ) -> BatchEncoding:
+        if images is None and text is None:
+            raise ValueError("You have to specify either images or text.")
+
+        # Get only text
+        if images is None:
+            self.current_processor = self.tokenizer
+            text_encoding = self.tokenizer(
+                text=text,
+                add_special_tokens=add_special_tokens,
+                padding=padding,
+                truncation=truncation,
+                max_length=max_length,
+                stride=stride,
+                pad_to_multiple_of=pad_to_multiple_of,
+                return_attention_mask=return_attention_mask,
+                return_overflowing_tokens=return_overflowing_tokens,
+                return_special_tokens_mask=return_special_tokens_mask,
+                return_offsets_mapping=return_offsets_mapping,
+                return_token_type_ids=return_token_type_ids,
+                return_length=return_length,
+                verbose=verbose,
+                return_tensors=return_tensors,
+                **kwargs,
+            )
+            return text_encoding
+
+        # add pixel_values
+        if images is not None:
+            encoding_image_processor = self.image_processor(images, return_tensors=return_tensors)
+            encoding_image_processor["pixel_values"] = torch.stack(
+                [torch.tensor(pixel_values) for pixel_values in encoding_image_processor["pixel_values"]]
+            ).unsqueeze(0)
+
+        if text is not None:
+            text_encoding = self.tokenizer(
+                text=text,
+                add_special_tokens=add_special_tokens,
+                padding=padding,
+                truncation=truncation,
+                max_length=max_length,
+                stride=stride,
+                pad_to_multiple_of=pad_to_multiple_of,
+                return_attention_mask=return_attention_mask,
+                return_overflowing_tokens=return_overflowing_tokens,
+                return_special_tokens_mask=return_special_tokens_mask,
+                return_offsets_mapping=return_offsets_mapping,
+                return_token_type_ids=return_token_type_ids,
+                return_length=return_length,
+                verbose=verbose,
+                return_tensors=return_tensors,
+                **kwargs,
+            )
+        else:
+            text_encoding = None
+
+        if text_encoding is not None:
+            encoding_image_processor.update(text_encoding)
+
+        return encoding_image_processor
+
+    def batch_decode(self, *args, **kwargs):
+        return self.tokenizer.batch_decode(*args, **kwargs)
+
+    def decode(self, *args, **kwargs):
+        return self.tokenizer.decode(*args, **kwargs)
+
+    @property
+    def model_input_names(self):
+        tokenizer_input_names = self.tokenizer.model_input_names
+        image_processor_input_names = self.image_processor.model_input_names
+        return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))

special_tokens_map.json

@@ -0,0 +1,23 @@
+{
+  "bos_token": {
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.model

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

tokenizer_config.json

@@ -0,0 +1,41 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<unk>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "<s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "</s>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [],
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "</s>",
+  "legacy": true,
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": null,
+  "processor_class": "CheXagentProcessor",
+  "sp_model_kwargs": {},
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": "<unk>",
+  "use_default_system_prompt": false
+}