Upload folder using huggingface_hub

config.json

@@ -0,0 +1,33 @@
+{
+  "architectures": [
+    "InfMLLMLlamaForCausalLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_infmllm_chat.InfMLLMChatConfig",
+    "AutoModel": "modeling_infmllm_chat.InfMLLMLlamaForCausalLM"
+  },
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "hidden_act": "silu",
+  "hidden_size": 4096,
+  "image_size": 448,
+  "initializer_range": 0.02,
+  "intermediate_size": 11008,
+  "max_position_embeddings": 4096,
+  "mm_hidden_size": 1408,
+  "mm_projector_type": "pooler",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 32,
+  "pad_token_id": 0,
+  "pool_out_size": "32+16+8",
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-05,
+  "rope_scaling": null,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.31.0",
+  "use_cache": true,
+  "vision_tower": "eva_clip_g",
+  "vocab_size": 32000
+}

configuration_infmllm_chat.py

@@ -0,0 +1,25 @@
+from transformers import PretrainedConfig
+from typing import List
+
+
+class InfMLLMChatConfig(PretrainedConfig):
+    def __init__(
+        self, 
+        image_size=448,
+        vision_tower="eva_clip_g", 
+        mm_projector_type="pooler",
+        pool_out_size="32+16+8",    
+        mm_hidden_size=1408,
+        hidden_size=4096,
+        **kwargs
+    ):
+        self.image_size = image_size
+        self.vision_tower = vision_tower
+        self.mm_projector_type = mm_projector_type
+        self.pool_out_size = pool_out_size
+        self.mm_hidden_size = mm_hidden_size
+        self.hidden_size = hidden_size
+        
+
+        super().__init__(**kwargs)
+        

eva_vit.py

@@ -0,0 +1,417 @@
+# Based on EVA, BEIT, timm and DeiT code bases
+# https://github.com/baaivision/EVA
+# https://github.com/rwightman/pytorch-image-models/tree/master/timm
+# https://github.com/microsoft/unilm/tree/master/beit
+# https://github.com/facebookresearch/deit/
+# https://github.com/facebookresearch/dino
+# --------------------------------------------------------'
+import math
+from functools import partial
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from timm.models.layers import drop_path, to_2tuple, trunc_normal_
+
+from transformers import CLIPImageProcessor
+
+
+class DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample  (when applied in main path of residual blocks).
+    """
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path(x, self.drop_prob, self.training)
+    
+    def extra_repr(self) -> str:
+        return 'p={}'.format(self.drop_prob)
+
+class Mlp(nn.Module):
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        # x = self.drop(x)
+        # commit this for the orignal BERT implement 
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+class Attention(nn.Module):
+    def __init__(
+            self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0.,
+            proj_drop=0., window_size=None, attn_head_dim=None):
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        if attn_head_dim is not None:
+            head_dim = attn_head_dim
+        all_head_dim = head_dim * self.num_heads
+        self.scale = qk_scale or head_dim ** -0.5
+
+        self.qkv = nn.Linear(dim, all_head_dim * 3, bias=False)
+        if qkv_bias:
+            self.q_bias = nn.Parameter(torch.zeros(all_head_dim))
+            self.v_bias = nn.Parameter(torch.zeros(all_head_dim))
+        else:
+            self.q_bias = None
+            self.v_bias = None
+
+        if window_size:
+            self.window_size = window_size
+            self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3
+            self.relative_position_bias_table = nn.Parameter(
+                torch.zeros(self.num_relative_distance, num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+            # cls to token & token 2 cls & cls to cls
+
+            # get pair-wise relative position index for each token inside the window
+            coords_h = torch.arange(window_size[0])
+            coords_w = torch.arange(window_size[1])
+            coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+            coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+            relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+            relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+            relative_coords[:, :, 0] += window_size[0] - 1  # shift to start from 0
+            relative_coords[:, :, 1] += window_size[1] - 1
+            relative_coords[:, :, 0] *= 2 * window_size[1] - 1
+            relative_position_index = \
+                torch.zeros(size=(window_size[0] * window_size[1] + 1, ) * 2, dtype=relative_coords.dtype)
+            relative_position_index[1:, 1:] = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+            relative_position_index[0, 0:] = self.num_relative_distance - 3
+            relative_position_index[0:, 0] = self.num_relative_distance - 2
+            relative_position_index[0, 0] = self.num_relative_distance - 1
+
+            self.register_buffer("relative_position_index", relative_position_index)
+        else:
+            self.window_size = None
+            self.relative_position_bias_table = None
+            self.relative_position_index = None
+
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(all_head_dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+    def forward(self, x, rel_pos_bias=None):
+        B, N, C = x.shape
+        qkv_bias = None
+        if self.q_bias is not None:
+            qkv_bias = torch.cat((self.q_bias, torch.zeros_like(self.v_bias, requires_grad=False), self.v_bias))
+        # qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias)
+        qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        if self.relative_position_bias_table is not None:
+            relative_position_bias = \
+                self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+                    self.window_size[0] * self.window_size[1] + 1,
+                    self.window_size[0] * self.window_size[1] + 1, -1)  # Wh*Ww,Wh*Ww,nH
+            relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+            attn = attn + relative_position_bias.unsqueeze(0)
+
+        if rel_pos_bias is not None:
+            attn = attn + rel_pos_bias
+        
+        attn = attn.softmax(dim=-1)
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B, N, -1)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+class Block(nn.Module):
+
+    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., init_values=None, act_layer=nn.GELU, norm_layer=nn.LayerNorm,
+                 window_size=None, attn_head_dim=None):
+        super().__init__()
+        self.norm1 = norm_layer(dim)
+        self.attn = Attention(
+            dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
+            attn_drop=attn_drop, proj_drop=drop, window_size=window_size, attn_head_dim=attn_head_dim)
+        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        if init_values is not None and init_values > 0:
+            self.gamma_1 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True)
+            self.gamma_2 = nn.Parameter(init_values * torch.ones((dim)),requires_grad=True)
+        else:
+            self.gamma_1, self.gamma_2 = None, None
+
+    def forward(self, x, rel_pos_bias=None):
+        if self.gamma_1 is None:
+            x = x + self.drop_path(self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias))
+            x = x + self.drop_path(self.mlp(self.norm2(x)))
+        else:
+            x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), rel_pos_bias=rel_pos_bias))
+            x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x)))
+        return x
+
+class PatchEmbed(nn.Module):
+    """ Image to Patch Embedding
+    """
+    def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0])
+        self.patch_shape = (img_size[0] // patch_size[0], img_size[1] // patch_size[1])
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.num_patches = num_patches
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+
+    def forward(self, x, **kwargs):
+        B, C, H, W = x.shape
+        # FIXME look at relaxing size constraints
+        assert H == self.img_size[0] and W == self.img_size[1], \
+            f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
+        x = self.proj(x).flatten(2).transpose(1, 2)
+        return x
+
+class RelativePositionBias(nn.Module):
+
+    def __init__(self, window_size, num_heads):
+        super().__init__()
+        self.window_size = window_size
+        self.num_relative_distance = (2 * window_size[0] - 1) * (2 * window_size[1] - 1) + 3
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros(self.num_relative_distance, num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+        # cls to token & token 2 cls & cls to cls
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(window_size[0])
+        coords_w = torch.arange(window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * window_size[1] - 1
+        relative_position_index = \
+            torch.zeros(size=(window_size[0] * window_size[1] + 1,) * 2, dtype=relative_coords.dtype)
+        relative_position_index[1:, 1:] = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        relative_position_index[0, 0:] = self.num_relative_distance - 3
+        relative_position_index[0:, 0] = self.num_relative_distance - 2
+        relative_position_index[0, 0] = self.num_relative_distance - 1
+
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        # trunc_normal_(self.relative_position_bias_table, std=.02)
+
+    def forward(self):
+        relative_position_bias = \
+            self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+                self.window_size[0] * self.window_size[1] + 1,
+                self.window_size[0] * self.window_size[1] + 1, -1)  # Wh*Ww,Wh*Ww,nH
+        return relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+
+class VisionTransformer(nn.Module):
+    """ Vision Transformer with support for patch or hybrid CNN input stage
+    """
+    def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
+                 num_heads=12, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0.,
+                 drop_path_rate=0., norm_layer=nn.LayerNorm, init_values=None,
+                 use_abs_pos_emb=True, use_rel_pos_bias=False, use_shared_rel_pos_bias=False,
+                 use_mean_pooling=True, init_scale=0.001, use_checkpoint=False):
+        super().__init__()
+        self.image_size = img_size
+        self.patch_size = patch_size
+        self.num_classes = num_classes
+        self.num_features = self.embed_dim = embed_dim  # num_features for consistency with other models
+
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim)
+        num_patches = self.patch_embed.num_patches
+
+        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
+        if use_abs_pos_emb:
+            self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim))
+        else:
+            self.pos_embed = None
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        if use_shared_rel_pos_bias:
+            self.rel_pos_bias = RelativePositionBias(window_size=self.patch_embed.patch_shape, num_heads=num_heads)
+        else:
+            self.rel_pos_bias = None
+        self.use_checkpoint = use_checkpoint
+        
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)]  # stochastic depth decay rule
+        self.use_rel_pos_bias = use_rel_pos_bias
+        self.blocks = nn.ModuleList([
+            Block(
+                dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
+                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer,
+                init_values=init_values, window_size=self.patch_embed.patch_shape if use_rel_pos_bias else None,
+                )
+            for i in range(depth)])
+#         self.norm = nn.Identity() if use_mean_pooling else norm_layer(embed_dim)
+#         self.fc_norm = norm_layer(embed_dim) if use_mean_pooling else None
+#         self.head = nn.Linear(embed_dim, num_classes) if num_classes > 0 else nn.Identity()
+
+        if self.pos_embed is not None:
+            trunc_normal_(self.pos_embed, std=.02)
+        trunc_normal_(self.cls_token, std=.02)
+        # trunc_normal_(self.mask_token, std=.02)
+#         if isinstance(self.head, nn.Linear):
+#             trunc_normal_(self.head.weight, std=.02)
+        self.apply(self._init_weights)
+        self.fix_init_weight()
+#         if isinstance(self.head, nn.Linear):
+#             self.head.weight.data.mul_(init_scale)
+#             self.head.bias.data.mul_(init_scale)
+
+    def fix_init_weight(self):
+        def rescale(param, layer_id):
+            param.div_(math.sqrt(2.0 * layer_id))
+
+        for layer_id, layer in enumerate(self.blocks):
+            rescale(layer.attn.proj.weight.data, layer_id + 1)
+            rescale(layer.mlp.fc2.weight.data, layer_id + 1)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def forward_features(self, x):
+        x = self.patch_embed(x)
+        batch_size, seq_len, _ = x.size()
+
+        cls_tokens = self.cls_token.expand(batch_size, -1, -1)  # stole cls_tokens impl from Phil Wang, thanks
+        x = torch.cat((cls_tokens, x), dim=1)
+        if self.pos_embed is not None:
+            x = x + self.pos_embed
+        x = self.pos_drop(x)
+
+        rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x, rel_pos_bias)
+            else:
+                x = blk(x, rel_pos_bias)
+        return x
+
+    def forward(self, x):
+        x = self.forward_features(x)
+        return x
+
+def interpolate_pos_embed(model, checkpoint_model):
+    if 'pos_embed' in checkpoint_model:
+        pos_embed_checkpoint = checkpoint_model['pos_embed'].float()
+        embedding_size = pos_embed_checkpoint.shape[-1]
+        num_patches = model.patch_embed.num_patches
+        num_extra_tokens = model.pos_embed.shape[-2] - num_patches
+        # height (== width) for the checkpoint position embedding
+        orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5)
+        # height (== width) for the new position embedding
+        new_size = int(num_patches ** 0.5)
+        # class_token and dist_token are kept unchanged
+        if orig_size != new_size:
+            print("Position interpolate from %dx%d to %dx%d" % (orig_size, orig_size, new_size, new_size))
+            extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]
+            # only the position tokens are interpolated
+            pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]
+            pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)
+            pos_tokens = torch.nn.functional.interpolate(
+                pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)
+            pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)
+            new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)
+            checkpoint_model['pos_embed'] = new_pos_embed
+
+
+class EVACLIPVisionTower(nn.Module):
+    def __init__(self, image_size):
+        super().__init__()
+        self.image_size = image_size
+        self.load_model()
+ 
+    def load_model(self):
+        self.image_processor = CLIPImageProcessor(
+            do_resize=True,
+            size=dict(shortest_edge=self.image_size),
+            resample=3,
+            do_center_crop=True,
+            crop_size=dict(height=self.image_size, width=self.image_size),
+            do_rescale=True,
+            rescale_factor=1/255,
+            do_normalize=True,
+            image_mean=[0.48145466, 0.4578275, 0.40821073],
+            image_std=[0.26862954, 0.26130258, 0.27577711],
+            do_convert_rgb=True,
+        )
+        self.vision_tower = VisionTransformer(img_size=self.image_size,
+                                            patch_size=14,
+                                            use_mean_pooling=False,
+                                            embed_dim=1408,
+                                            depth=39,
+                                            num_heads=1408//88,
+                                            mlp_ratio=4.3637,
+                                            qkv_bias=True,
+                                            drop_path_rate=0.,
+                                            norm_layer=partial(nn.LayerNorm, eps=1e-6),
+                                            use_checkpoint=False)
+        self.ln_vision = nn.LayerNorm(self.vision_tower.embed_dim)
+
+    @torch.no_grad()
+    def forward(self, images):
+        if type(images) is list:
+            image_features = []
+            for image in images:
+                image_forward_out = self.ln_vision(self.vision_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0)))
+                image_feature = image_forward_out.to(image.dtype)
+                image_features.append(image_feature)
+        else:
+            image_forward_outs = self.ln_vision(self.vision_tower(images.to(device=self.device, dtype=self.dtype)))
+            image_features = image_forward_outs.to(images.dtype)
+
+        return image_features
+
+    @property
+    def dummy_feature(self):
+        return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)
+
+    @property
+    def dtype(self):
+        #return self.vision_tower.dtype
+        return next(self.vision_tower.parameters()).dtype
+
+    @property
+    def device(self):
+        #return self.vision_tower.device
+        return next(self.vision_tower.parameters()).device
+    
+    @property
+    def hidden_size(self):
+        return self.vision_tower.embed_dim
+
+    @property
+    def num_patches(self):
+        return (self.vision_tower.image_size // self.vision_tower.patch_size) ** 2
+    

generation_config.json

@@ -0,0 +1,7 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 1,
+  "eos_token_id": 2,
+  "pad_token_id": 0,
+  "transformers_version": "4.31.0"
+}

modeling_infmllm_chat.py

@@ -0,0 +1,273 @@
+# Thanks to the open source code of LLaVA-1.5
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Tuple, Union
+import torch
+import torch.nn as nn
+from torch.nn import CrossEntropyLoss
+
+from transformers import LlamaModel, LlamaForCausalLM
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+from .eva_vit import EVACLIPVisionTower
+from .pooler import Pooler
+
+IGNORE_INDEX = -100
+IMAGE_TOKEN_INDEX = -200
+
+
+class LlavaMetaModel:
+    def __init__(self, config):
+        super(LlavaMetaModel, self).__init__(config)
+        self.vision_tower = EVACLIPVisionTower(config.image_size)
+        self.mm_projector = Pooler(config.mm_hidden_size, config.hidden_size, 
+                                   pool_out_size=config.pool_out_size)
+
+    def get_vision_tower(self):
+        return self.vision_tower
+
+class InfMLLMLlamaModel(LlavaMetaModel, LlamaModel):
+    def __init__(self, config):
+        super(InfMLLMLlamaModel, self).__init__(config)
+
+
+class InfMLLMMetaForCausalLM(ABC):
+
+    @abstractmethod
+    def get_model(self):
+        pass
+
+    def get_vision_tower(self):
+        return self.get_model().get_vision_tower()
+
+    def encode_images(self, images):
+        image_features = self.get_model().get_vision_tower()(images)
+        image_features = self.get_model().mm_projector(image_features)
+        return image_features
+
+    def prepare_inputs_labels_for_multimodal(
+        self, 
+        input_ids,          # [b, L]
+        attention_mask,     # [b, L]
+        past_key_values,    # None
+        labels,             # [b, L]
+        images              # [b, 3, 336, 336]
+    ):
+        vision_tower = self.get_vision_tower()
+        if vision_tower is None or images is None or input_ids.shape[1] == 1:
+            if past_key_values is not None and vision_tower is not None and images is not None and input_ids.shape[1] == 1:
+                attention_mask = torch.ones((attention_mask.shape[0], past_key_values[-1][-1].shape[-2] + 1), dtype=attention_mask.dtype, device=attention_mask.device)
+            return input_ids, attention_mask, past_key_values, None, labels
+
+        if type(images) is list or images.ndim == 5:
+            concat_images = torch.cat([image for image in images], dim=0)
+            image_features = self.encode_images(concat_images)
+            split_sizes = [image.shape[0] for image in images]
+            image_features = torch.split(image_features, split_sizes, dim=0)
+            image_features = [x.flatten(0, 1) for x in image_features]
+        else:
+            image_features = self.encode_images(images)                             # [b, 576, 5120]
+
+        new_input_embeds = []
+        new_labels = [] if labels is not None else None
+        cur_image_idx = 0
+        for batch_idx, cur_input_ids in enumerate(input_ids):
+            if (cur_input_ids == IMAGE_TOKEN_INDEX).sum() == 0:
+                # multimodal LLM, but the current sample is not multimodal
+                # FIXME: this is a hacky fix, for deepspeed zero3 to work
+                half_len = cur_input_ids.shape[0] // 2
+                cur_image_features = image_features[cur_image_idx]
+                cur_input_embeds_1 = self.get_model().embed_tokens(cur_input_ids[:half_len])
+                cur_input_embeds_2 = self.get_model().embed_tokens(cur_input_ids[half_len:])
+                cur_input_embeds = torch.cat([cur_input_embeds_1, cur_image_features[0:0], cur_input_embeds_2], dim=0)
+                new_input_embeds.append(cur_input_embeds)
+                if labels is not None:
+                    new_labels.append(labels[batch_idx])
+                cur_image_idx += 1
+                continue
+
+            image_token_indices = torch.where(cur_input_ids == IMAGE_TOKEN_INDEX)[0]
+            cur_new_input_embeds = []
+            if labels is not None:
+                cur_labels = labels[batch_idx]
+                cur_new_labels = []
+                assert cur_labels.shape == cur_input_ids.shape
+
+            while image_token_indices.numel() > 0:
+                cur_image_features = image_features[cur_image_idx]
+                image_token_start = image_token_indices[0]
+                #if getattr(self.config, 'tune_mm_mlp_adapter', False) and getattr(self.config, 'mm_use_im_start_end', False):
+                #    cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids[:image_token_start-1]).detach())
+                #    cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids[image_token_start-1:image_token_start]))
+                #    cur_new_input_embeds.append(cur_image_features)
+                #    cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids[image_token_start+1:image_token_start+2]))
+                #    if labels is not None:
+                #        cur_new_labels.append(cur_labels[:image_token_start])
+                #        cur_new_labels.append(torch.full((cur_image_features.shape[0],), IGNORE_INDEX, device=labels.device, dtype=labels.dtype))
+                #        cur_new_labels.append(cur_labels[image_token_start:image_token_start+1])
+                #        cur_labels = cur_labels[image_token_start+2:]
+                #else:
+
+                cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids[:image_token_start]))
+                cur_new_input_embeds.append(cur_image_features)
+                if labels is not None:
+                    cur_new_labels.append(cur_labels[:image_token_start])
+                    cur_new_labels.append(torch.full((cur_image_features.shape[0],), IGNORE_INDEX, device=labels.device, dtype=labels.dtype))
+                    cur_labels = cur_labels[image_token_start+1:]
+                cur_image_idx += 1
+                
+                #if getattr(self.config, 'tune_mm_mlp_adapter', False) and getattr(self.config, 'mm_use_im_start_end', False):
+                #    cur_input_ids = cur_input_ids[image_token_start+2:]
+                #else:
+                cur_input_ids = cur_input_ids[image_token_start+1:]
+                image_token_indices = torch.where(cur_input_ids == IMAGE_TOKEN_INDEX)[0]
+                
+            if cur_input_ids.numel() > 0:
+                #if getattr(self.config, 'tune_mm_mlp_adapter', False) and getattr(self.config, 'mm_use_im_start_end', False):
+                #    cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids).detach())
+                #else:
+                cur_new_input_embeds.append(self.get_model().embed_tokens(cur_input_ids))
+                if labels is not None:
+                    cur_new_labels.append(cur_labels)
+            cur_new_input_embeds = [x.to(device=self.device) for x in cur_new_input_embeds]
+            cur_new_input_embeds = torch.cat(cur_new_input_embeds, dim=0)
+            new_input_embeds.append(cur_new_input_embeds)
+            if labels is not None:
+                cur_new_labels = torch.cat(cur_new_labels, dim=0)
+                new_labels.append(cur_new_labels)
+
+        if any(x.shape != new_input_embeds[0].shape for x in new_input_embeds):
+            max_len = max(x.shape[0] for x in new_input_embeds)
+
+            new_input_embeds_align = []
+            for cur_new_embed in new_input_embeds:
+                cur_new_embed = torch.cat((cur_new_embed, torch.zeros((max_len - cur_new_embed.shape[0], cur_new_embed.shape[1]), dtype=cur_new_embed.dtype, device=cur_new_embed.device)), dim=0)
+                new_input_embeds_align.append(cur_new_embed)
+            new_input_embeds = torch.stack(new_input_embeds_align, dim=0)
+
+            if labels is not None:
+                new_labels_align = []
+                _new_labels = new_labels
+                for cur_new_label in new_labels:
+                    cur_new_label = torch.cat((cur_new_label, torch.full((max_len - cur_new_label.shape[0],), IGNORE_INDEX, dtype=cur_new_label.dtype, device=cur_new_label.device)), dim=0)
+                    new_labels_align.append(cur_new_label)
+                new_labels = torch.stack(new_labels_align, dim=0)
+
+            if attention_mask is not None:
+                new_attention_mask = []
+                for cur_attention_mask, cur_new_labels, cur_new_labels_align in zip(attention_mask, _new_labels, new_labels):
+                    new_attn_mask_pad_left = torch.full((cur_new_labels.shape[0] - labels.shape[1],), True, dtype=attention_mask.dtype, device=attention_mask.device)
+                    new_attn_mask_pad_right = torch.full((cur_new_labels_align.shape[0] - cur_new_labels.shape[0],), False, dtype=attention_mask.dtype, device=attention_mask.device)
+                    cur_new_attention_mask = torch.cat((new_attn_mask_pad_left, cur_attention_mask, new_attn_mask_pad_right), dim=0)
+                    new_attention_mask.append(cur_new_attention_mask)
+                attention_mask = torch.stack(new_attention_mask, dim=0)
+                assert attention_mask.shape == new_labels.shape
+        else:
+            new_input_embeds = torch.stack(new_input_embeds, dim=0)
+            if labels is not None:
+                new_labels  = torch.stack(new_labels, dim=0)
+
+            if attention_mask is not None:
+                new_attn_mask_pad_left = torch.full((attention_mask.shape[0], new_input_embeds.shape[1] - input_ids.shape[1]), True, dtype=attention_mask.dtype, device=attention_mask.device)
+                attention_mask = torch.cat((new_attn_mask_pad_left, attention_mask), dim=1)
+                assert attention_mask.shape == new_input_embeds.shape[:2]
+
+        return None, attention_mask, past_key_values, new_input_embeds, new_labels
+
+
+class InfMLLMLlamaForCausalLM(LlamaForCausalLM, InfMLLMMetaForCausalLM):
+
+    def __init__(self, config):
+        super(LlamaForCausalLM, self).__init__(config)
+        self.model = InfMLLMLlamaModel(config)
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_model(self):
+        return self.model
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        images: Optional[torch.FloatTensor] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions       # False
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )   # False
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict                           # True
+
+        input_ids, attention_mask, past_key_values, inputs_embeds, labels = self.prepare_inputs_labels_for_multimodal(input_ids, attention_mask, past_key_values, labels, images)
+
+        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict
+        )
+
+        hidden_states = outputs[0]
+        logits = self.lm_head(hidden_states)
+
+        loss = None
+        if labels is not None:
+            # Shift so that tokens < n predict n
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            # Flatten the tokens
+            loss_fct = CrossEntropyLoss()
+            shift_logits = shift_logits.view(-1, self.config.vocab_size)
+            shift_labels = shift_labels.view(-1)
+            # Enable model/pipeline parallelism
+            shift_labels = shift_labels.to(shift_logits.device)
+            loss = loss_fct(shift_logits, shift_labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[1:]
+            return (loss,) + output if loss is not None else output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def prepare_inputs_for_generation(
+        self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
+    ):
+        if past_key_values:
+            input_ids = input_ids[:, -1:]
+
+        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
+        if inputs_embeds is not None and past_key_values is None:
+            model_inputs = {"inputs_embeds": inputs_embeds}
+        else:
+            model_inputs = {"input_ids": input_ids}
+
+        model_inputs.update(
+            {
+                "past_key_values": past_key_values,
+                "use_cache": kwargs.get("use_cache"),
+                "attention_mask": attention_mask,
+                "images": kwargs.get("images", None),
+            }
+        )
+        return model_inputs
+    

pooler.py

@@ -0,0 +1,49 @@
+import torch 
+import torch.nn as nn 
+import math
+import random
+
+
+class Pooler(nn.Module):
+    def __init__(self, dim_in, dim_out, pool_out_size):
+        super().__init__()
+        assert isinstance(pool_out_size, str)
+        self.pool_out_size = pool_out_size.split(",")
+        print("pool_out_size: {}".format(self.pool_out_size))
+
+        self.mlp = nn.Sequential(
+            nn.Linear(dim_in, dim_out),
+            nn.GELU(),
+            nn.Linear(dim_out, dim_out)
+        )
+                
+    def forward(self, x):
+        """
+        Args:
+            x (torch.Tensor): image features
+                shape (b, v, D)
+        Returns:
+            shape (b, n, D) where n is self.num_latents
+        """
+        b, v, d = x.shape
+        s = int(math.sqrt(v -1))
+        x = x[:, 1:, :]           # remove cls_token
+        x_in = x.reshape(b, s, s, d)
+
+        pool_out_size = random.choice(self.pool_out_size)
+
+        if '+' in pool_out_size:        # "16+32" means ensemble the pool size of 16 and 32
+            pool_out_size_list = [int(p) for p in pool_out_size.split('+')]
+        else:
+            pool_out_size_list = [int(pool_out_size)]
+        pool_out_size_list.sort(reverse=True)
+
+        x_out = []
+        for pool_out_size in pool_out_size_list:
+            assert s % pool_out_size == 0 
+            x = x_in.reshape(b, pool_out_size, s//pool_out_size, pool_out_size, s//pool_out_size, d)
+            x = x.permute([0, 1, 3, 5, 2, 4]).reshape(b, pool_out_size * pool_out_size, d, -1).mean(-1)
+            x = self.mlp(x)                 # [b, h*w, d]
+            x_out.append(x)
+        x_out = torch.cat(x_out, dim=-2)
+        return x_out

pytorch_model-00001-of-00004.bin

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

pytorch_model-00002-of-00004.bin

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

pytorch_model-00003-of-00004.bin

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

pytorch_model-00004-of-00004.bin

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

pytorch_model.bin.index.json

@@ -0,0 +1,847 @@
+{
+  "metadata": {
+    "total_size": 30991795712
+  },
+  "weight_map": {
+    "lm_head.weight": "pytorch_model-00004-of-00004.bin",
+    "model.embed_tokens.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.0.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.1.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.10.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.11.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.11.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.11.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.11.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.11.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.12.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.12.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.13.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.14.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.15.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.16.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.17.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.18.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.19.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.2.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.2.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.20.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.20.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.21.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.input_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.mlp.down_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.post_attention_layernorm.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.22.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.23.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.23.mlp.gate_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.mlp.up_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.23.self_attn.k_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.self_attn.o_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.self_attn.q_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00004.bin",
+    "model.layers.23.self_attn.v_proj.weight": "pytorch_model-00002-of-00004.bin",
+    "model.layers.24.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.24.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.25.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.26.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.27.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.28.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.29.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.3.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.3.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.30.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.30.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.input_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.mlp.down_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.mlp.gate_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.mlp.up_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.post_attention_layernorm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.self_attn.k_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.self_attn.o_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.self_attn.q_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00004.bin",
+    "model.layers.31.self_attn.v_proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.layers.4.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.4.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.5.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.6.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.7.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.8.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.input_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.mlp.down_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.mlp.gate_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.mlp.up_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.post_attention_layernorm.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.self_attn.k_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.self_attn.o_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.self_attn.q_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00004.bin",
+    "model.layers.9.self_attn.v_proj.weight": "pytorch_model-00001-of-00004.bin",
+    "model.mm_projector.mlp.0.bias": "pytorch_model-00004-of-00004.bin",
+    "model.mm_projector.mlp.0.weight": "pytorch_model-00004-of-00004.bin",
+    "model.mm_projector.mlp.2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.mm_projector.mlp.2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.norm.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.ln_vision.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.ln_vision.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.0.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.1.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.10.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.11.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.12.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.13.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.14.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.15.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.16.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.17.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.18.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.19.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.2.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.20.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.21.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.22.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.23.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.24.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.25.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.26.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.27.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.28.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.29.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.3.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.30.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.31.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.32.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.33.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.attn.q_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.attn.v_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.norm1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.norm1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.34.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.attn.q_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.attn.v_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.norm1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.norm1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.35.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.attn.q_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.attn.v_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.norm1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.norm1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.36.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.attn.q_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.attn.v_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.norm1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.norm1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.37.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.attn.proj.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.attn.proj.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.attn.q_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.attn.qkv.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.attn.v_bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.mlp.fc1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.mlp.fc1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.mlp.fc2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.mlp.fc2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.norm1.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.norm1.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.norm2.bias": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.38.norm2.weight": "pytorch_model-00004-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.4.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.5.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.6.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.7.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.8.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.attn.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.attn.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.attn.q_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.attn.qkv.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.attn.v_bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.mlp.fc1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.mlp.fc1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.mlp.fc2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.mlp.fc2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.norm1.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.norm1.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.norm2.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.blocks.9.norm2.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.cls_token": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.patch_embed.proj.bias": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.patch_embed.proj.weight": "pytorch_model-00003-of-00004.bin",
+    "model.vision_tower.vision_tower.pos_embed": "pytorch_model-00003-of-00004.bin"
+  }
+}

special_tokens_map.json

@@ -0,0 +1,24 @@
+{
+  "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
+  },
+  "pad_token": "<unk>",
+  "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:9e556afd44213b6bd1be2b850ebbbd98f5481437a8021afaf58ee7fb1818d347
+size 499723

tokenizer_config.json

@@ -0,0 +1,35 @@
+{
+  "add_bos_token": true,
+  "add_eos_token": false,
+  "bos_token": {
+    "__type": "AddedToken",
+    "content": "<s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "clean_up_tokenization_spaces": false,
+  "eos_token": {
+    "__type": "AddedToken",
+    "content": "</s>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "legacy": false,
+  "model_max_length": 4096,
+  "pad_token": null,
+  "padding_side": "right",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "LlamaTokenizer",
+  "unk_token": {
+    "__type": "AddedToken",
+    "content": "<unk>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}