Upload folder using huggingface_hub

config.json

@@ -0,0 +1,17 @@
+{
+  "architectures": [
+    "InfMLLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_infmllm.InfMLLMConfig",
+    "AutoModel": "modeling_infmllm.InfMLLM"
+  },
+  "image_size": 448,
+  "lm_model": "pretrain_models/lmsys/vicuna-7b-v1.5/",
+  "lm_tokenizer": "pretrain_models/lmsys/vicuna-7b-v1.5/",
+  "pool_out_size": "32+16+8",
+  "precision": "amp_bf16",
+  "torch_dtype": "float32",
+  "transformers_version": "4.31.0",
+  "vit_model": "eva_clip_g"
+}

configuration_infmllm.py

@@ -0,0 +1,23 @@
+from transformers import PretrainedConfig
+from typing import List
+
+
+class InfMLLMConfig(PretrainedConfig):
+    def __init__(
+        self, 
+        image_size="448",
+        vit_model="eva_clip_g", 
+        pool_out_size="32",
+        lm_model="pretrain_models/lmsys/vicuna-7b-v1.5/",
+        lm_tokenizer="pretrain_models/lmsys/vicuna-7b-v1.5/",
+        precision="amp_bf16",
+        **kwargs
+    ):
+        self.image_size = image_size
+        self.vit_model = vit_model
+        self.pool_out_size = pool_out_size
+        self.lm_model = lm_model
+        self.lm_tokenizer = lm_tokenizer
+        self.precision = precision
+        super().__init__(**kwargs)
+        

eva_vit.py

@@ -0,0 +1,412 @@
+# 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 os
+import math
+from functools import partial
+import glob
+
+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_
+
+
+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
+
+        # 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)
+
+    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.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)])
+
+        if self.pos_embed is not None:
+            trunc_normal_(self.pos_embed, std=.02)
+        trunc_normal_(self.cls_token, std=.02)
+
+        self.apply(self._init_weights)
+        self.fix_init_weight()
+
+    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 get_classifier(self):
+        return self.head
+
+    def reset_classifier(self, num_classes, global_pool=''):
+        self.num_classes = num_classes
+        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
+
+    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 get_intermediate_layers(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)
+
+        features = []
+        rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None
+        for blk in self.blocks:
+            x = blk(x, rel_pos_bias)
+            features.append(x)
+
+        return features
+    
+    def get_num_layer(self, var_name=""):
+        if var_name in ("cls_token", "mask_token", "pos_embed"):
+            return 0
+        elif var_name.startswith("patch_embed"):
+            return 0
+        elif var_name.startswith("rel_pos_bias"):
+            return len(self.blocks) - 1
+        elif var_name.startswith("blocks"):
+            layer_id = int(var_name.split('.')[1])
+            return layer_id + 1
+        else:
+            return len(self.blocks)
+        
+            
+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
+            
+            
+def convert_weights_to_fp16(model: nn.Module):
+    """Convert applicable model parameters to fp16"""
+
+    def _convert_weights_to_fp16(l):
+        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
+            l.weight.data = l.weight.data.half()
+            if l.bias is not None:
+                l.bias.data = l.bias.data.half()
+
+    model.apply(_convert_weights_to_fp16)
+    
+    
+def create_eva_vit_g(img_size=224, 
+                     drop_path_rate=0.4, 
+                     use_checkpoint=False):
+    
+    model = VisionTransformer(
+        img_size=img_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=drop_path_rate,
+        norm_layer=partial(nn.LayerNorm, eps=1e-6),
+        use_checkpoint=use_checkpoint,
+    )  
+    return model

modeling_infmllm.py

@@ -0,0 +1,286 @@
+import logging
+import torch
+import torch.nn as nn
+from contextlib import suppress
+from einops import rearrange
+from transformers import LlamaForCausalLM, LlamaTokenizer, PreTrainedModel
+from torchvision import transforms
+from torchvision.transforms.functional import InterpolationMode
+
+from .eva_vit import create_eva_vit_g
+from .pooler import Pooler
+
+
+def get_autocast(precision, cache_enabled=True):
+    if precision == "amp":
+        return lambda: torch.cuda.amp.autocast(cache_enabled=cache_enabled)
+    elif precision == "amp_bfloat16" or precision == "amp_bf16" or precision == 'bf16':
+        return lambda: torch.cuda.amp.autocast(dtype=torch.bfloat16, cache_enabled=cache_enabled)
+    elif precision == 'fp16':
+        return lambda: torch.cuda.amp.autocast(dtype=torch.float16, cache_enabled=cache_enabled)
+    elif precision == 'fp32':
+        return suppress
+    else:
+        raise ValueError('not supported precision: {}'.format(precision))
+    
+class LayerNorm(nn.LayerNorm):
+    """Subclass torch's LayerNorm to handle fp16."""
+    def forward(self, x: torch.Tensor):
+        orig_type = x.dtype
+        ret = super().forward(x.type(torch.float32))
+        return ret.type(orig_type)
+
+def init_vision_encoder(model_name, 
+                        img_size, 
+                        drop_path_rate, 
+                        use_grad_checkpoint):
+    if model_name == "eva_clip_g":
+        visual_encoder = create_eva_vit_g(
+            img_size, drop_path_rate, use_grad_checkpoint)
+    else:
+        raise ValueError()
+    
+    ln_vision = LayerNorm(visual_encoder.num_features)
+    return visual_encoder, ln_vision
+
+class ImageProcessor:
+    def __init__(self, image_size=364, mean=None, std=None):
+        if mean is None:
+            self.mean = mean = (0.48145466, 0.4578275, 0.40821073)
+        if std is None:
+            self.std = std = (0.26862954, 0.26130258, 0.27577711)
+
+        self.normalize = transforms.Normalize(mean, std)
+        self.transform = transforms.Compose(
+            [
+                transforms.Resize(
+                    (image_size, image_size), interpolation=InterpolationMode.BICUBIC
+                ),
+                transforms.ToTensor(),
+                self.normalize,
+            ]
+        )
+
+    def __call__(self, item):
+        return self.transform(item)
+    
+class InfMLLM(PreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        vit_model = config.vit_model
+        img_size = config.image_size
+        lm_model = config.lm_model 
+        lm_tokenizer = config.lm_tokenizer
+        precision = config.precision
+        pool_out_size = config.pool_out_size
+        self.img_processor = ImageProcessor(image_size=img_size)
+
+        self.visual_encoder, self.ln_vision = init_vision_encoder(
+            vit_model, img_size, drop_path_rate=0.0, use_grad_checkpoint=False)
+
+        self.lm_tokenizer = LlamaTokenizer.from_pretrained(lm_tokenizer, use_fast=False, trust_remote_code=True)
+        self.lm_tokenizer.pad_token = self.lm_tokenizer.unk_token
+        self.lm_model = LlamaForCausalLM.from_pretrained(lm_model, trust_remote_code=True, torch_dtype='auto')
+        
+        self.pooler = Pooler(dim_in=self.visual_encoder.num_features,
+                                dim_out=self.lm_model.config.hidden_size,
+                                pool_out_size=pool_out_size)
+        self.llama_proj = nn.Identity()
+        
+        self.precision = precision
+        self._apply_lemmatizer = config.apply_lemmatizer if hasattr(config, 'apply_lemmatizer') else False
+        self._lemmatizer = None  
+    
+    def prompt_wrap(self, img_embeds, atts_img, prompts):
+        assert len(img_embeds) == len(atts_img) == len(prompts)
+
+        bos = torch.ones([1, 1], dtype=torch.long, device=img_embeds.device) * self.lm_tokenizer.bos_token_id
+        bos_embeds = self.lm_model.get_input_embeddings()(bos)
+
+        emb_lists = []
+        image_mask = []
+        for each_img_embed, each_prompt in zip(img_embeds, prompts):
+            assert '<ImageHere>' in each_prompt
+            p_before, p_after = each_prompt.split('<ImageHere>')
+
+            p_before_tokens = self.lm_tokenizer(
+                p_before, return_tensors="pt", add_special_tokens=False).to(img_embeds.device)
+            p_after_tokens = self.lm_tokenizer(
+                p_after, return_tensors="pt", add_special_tokens=False).to(img_embeds.device)
+            
+            p_before_embed = self.lm_model.get_input_embeddings()(p_before_tokens.input_ids.long())                                     # [1, 6, 4096]
+            p_after_embed = self.lm_model.get_input_embeddings()(p_after_tokens.input_ids.long())                                       # [1, 17, 4096]
+            # add 1 bos
+            wrapped_emb = torch.cat([bos_embeds, p_before_embed, each_img_embed[None], p_after_embed], dim=1)                           # [1, 87, 4096]
+            emb_lists.append(wrapped_emb)
+
+            image_mask.append( torch.tensor([0] * wrapped_emb.size(1)) )
+            image_mask[-1][range(bos_embeds.size(1) + p_before_embed.size(1), 
+                                     bos_embeds.size(1) + p_before_embed.size(1) + len(each_img_embed))] = 1
+            assert image_mask[-1].sum() == each_img_embed.size(0)
+
+        emb_lens = [emb.shape[1] for emb in emb_lists]
+        pad_emb = self.lm_model.get_input_embeddings()(torch.tensor(self.lm_tokenizer.pad_token_id, device=img_embeds.device))          # [4096]
+        
+        assert not self.training 
+        # during inference mode, padding on the left
+        wrapped_embs = pad_emb.expand(len(emb_lens), max(emb_lens), -1).clone()                                                         # [12, 87, 4096]
+        wrapped_atts = torch.zeros([len(emb_lens), max(emb_lens)], dtype=torch.int, device=img_embeds.device)                           # [12, 87]
+        wrapped_image_masks = torch.zeros([len(emb_lens), max(emb_lens)], dtype=torch.int, device=img_embeds.device)                    # [12, 87]
+        for i, emb in enumerate(emb_lists):
+            wrapped_embs[i, -emb_lens[i]:] = emb
+            wrapped_atts[i, -emb_lens[i]:] = 1
+            wrapped_image_masks[i, -emb_lens[i]:] = image_mask[i]
+        return wrapped_embs, wrapped_atts, wrapped_image_masks
+
+    @torch.no_grad()
+    def forward_image_feature(self, image):
+        autocast = get_autocast(self.precision, cache_enabled=True)
+        with autocast():
+            if image.ndim == 4:
+                image = image.unsqueeze(1).unsqueeze(1)                                             
+            assert image.ndim == 6
+
+            b, t, f = image.shape[:3]
+            assert t == 1 and f == 1
+            image = rearrange(image, "b t f c h w -> (b t f) c h w")
+
+            image_embeds = self.ln_vision(self.visual_encoder(image))
+            
+            image_embeds = rearrange(image_embeds, "(b t f) L D -> b t f L D", t=t, f=f)
+            query_output= self.pooler(image_embeds)
+            query_output = query_output.squeeze(1)
+            embeds_img = self.llama_proj(query_output)
+            
+            return embeds_img
+        
+    @torch.no_grad()
+    def generate(
+        self,
+        samples,
+        use_nucleus_sampling=False,
+        num_beams=5,
+        max_length=30,
+        min_length=1,
+        top_p=0.9,
+        repetition_penalty=1.0,
+        length_penalty=1.0,
+        num_captions=1,
+        temperature=1,
+    ):
+        autocast = get_autocast(self.precision, cache_enabled=True)
+        with autocast():
+            image = samples["image"]  
+            embeds_img = self.forward_image_feature(image)
+            atts_img = torch.ones(embeds_img.size()[:-1], dtype=torch.long).to(image.device)
+
+            prompts = samples["prompts"]
+            assert isinstance(prompts, (tuple, list))
+
+            # Convert prompts to embeds and, repalce "<ImageHere>" with img_embeds
+            inputs_embeds, attention_mask, masks_img = self.prompt_wrap(embeds_img, atts_img, prompts)
+            
+            model_args = dict(
+                inputs_embeds=inputs_embeds, 
+                attention_mask=attention_mask,
+                do_sample=use_nucleus_sampling,
+                top_p=top_p,
+                temperature=temperature,
+                num_beams=num_beams,
+                max_length=max_length,
+                min_length=min_length,
+                eos_token_id=self.lm_tokenizer.eos_token_id,
+                repetition_penalty=repetition_penalty,
+                length_penalty=length_penalty,
+                num_return_sequences=num_captions,
+            )
+            outputs = self.lm_model.generate(**model_args)
+
+            output_text = self.lm_tokenizer.batch_decode(
+                outputs, skip_special_tokens=True
+            )
+                     
+            output_text = [text.strip() for text in output_text]
+
+        return output_text
+        
+    @torch.no_grad()   
+    def predict_answers(
+        self,
+        samples,
+        num_beams=5,
+        max_len=10,
+        min_len=1,
+        length_penalty=0,
+    ):
+        # VQA tasks
+        autocast = get_autocast(self.precision, cache_enabled=True)
+        with autocast():
+            image = samples["image"]  
+            embeds_img = self.forward_image_feature(image)
+            atts_img = torch.ones(embeds_img.size()[:-1], dtype=torch.long).to(image.device)
+            
+            prompts = samples["prompts"]
+            assert isinstance(prompts, (tuple, list))
+
+            inputs_embeds, attention_mask, masks_img = self.prompt_wrap(embeds_img, atts_img, prompts)
+
+            model_args = dict(
+                inputs_embeds=inputs_embeds,
+                attention_mask=attention_mask,
+                do_sample=False,
+                num_beams=num_beams,
+                max_new_tokens=max_len,
+                min_length=min_len,
+                eos_token_id=self.lm_tokenizer.eos_token_id,
+                length_penalty=length_penalty
+            )
+
+            outputs = self.lm_model.generate(**model_args)
+            output_text = self.lm_tokenizer.batch_decode(
+                outputs, skip_special_tokens=True
+            )
+            output_text = [text.strip() for text in output_text]
+
+        if self._apply_lemmatizer or ("apply_lemmatizer" in samples.keys() and samples["apply_lemmatizer"]):
+            output_text = self._lemmatize(output_text)
+
+        return output_text
+    
+    def _lemmatize(self, answers):
+        def apply(answer):
+            doc = self.lemmatizer(answer)
+
+            words = []
+            for token in doc:
+                if token.pos_ in ["NOUN", "VERB"]:
+                    words.append(token.lemma_)
+                else:
+                    words.append(token.text)
+            answer = " ".join(words)
+
+            return answer
+
+        return [apply(answer) for answer in answers]
+    
+    @property
+    def lemmatizer(self):
+        if self._lemmatizer is None:
+            try:
+                import spacy
+
+                self._lemmatizer = spacy.load("en_core_web_sm")
+            except ImportError:
+                logging.error(
+                    """
+                    Please install spacy and en_core_web_sm model to apply lemmatization.
+                    python -m spacy download en_core_web_sm
+                    OR
+                    import spacy.cli
+                    spacy.cli.download("en_core_web_sm")
+                    """
+                )
+                exit(1)
+
+        return self._lemmatizer
+    

pooler.py

@@ -0,0 +1,52 @@
+import random
+import math
+import torch 
+import torch.nn as nn
+
+
+class Pooler(nn.Module):
+    def __init__(self, dim_in, dim_out, pool_out_size):
+        super().__init__()
+        if not isinstance(pool_out_size, (list, tuple)):
+            pool_out_size = [pool_out_size]
+
+        self.pool_out_size = pool_out_size
+        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, T, F, v, D)
+        Returns:
+            shape (b, T, n, D) where n is self.num_latents
+        """
+        b, t, f, v, d = x.shape
+        s = int(math.sqrt(v -1))
+        assert t == 1 and f == 1 
+        x = x[:, :, :, 1:, :]           # remove cls_token
+        x_in = x.reshape(b, t, f, 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:
+            x = x_in.reshape(b, t, f, pool_out_size, s//pool_out_size, pool_out_size, s//pool_out_size, d)
+            x = x.permute([0, 1, 2, 3, 5, 7, 4, 6]).reshape(b, t, f, pool_out_size * pool_out_size, d, -1).mean(-1)
+            x = self.mlp(x)                 # [b, t, f, h*w, d]
+            x = x.flatten(0, 2)
+            x_out.append(x)
+        x_out = torch.cat(x_out, dim=-2)
+
+        return x_out.unsqueeze(1)

pytorch_model-00001-of-00002.bin

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

pytorch_model-00002-of-00002.bin

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

pytorch_model.bin.index.json

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