


import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)
def 				__lowerCamelCase						( UpperCAmelCase_						:		List[Any] ,  UpperCAmelCase_						:		Optional[Any]=False						):




      """simple docstring"""





      a						:int 							=       []
      for i in range(config.num_hidden_layers						):
            # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
            rename_keys.append((F'''module.blocks.{i}.norm1.weight''', F'''vit.encoder.layer.{i}.layernorm_before.weight''')						)
            rename_keys.append((F'''module.blocks.{i}.norm1.bias''', F'''vit.encoder.layer.{i}.layernorm_before.bias''')						)
            rename_keys.append(
                (F'''module.blocks.{i}.attn.proj.weight''', F'''vit.encoder.layer.{i}.attention.output.dense.weight''')						)
            rename_keys.append((F'''module.blocks.{i}.attn.proj.bias''', F'''vit.encoder.layer.{i}.attention.output.dense.bias''')						)
            rename_keys.append((F'''module.blocks.{i}.norm2.weight''', F'''vit.encoder.layer.{i}.layernorm_after.weight''')						)
            rename_keys.append((F'''module.blocks.{i}.norm2.bias''', F'''vit.encoder.layer.{i}.layernorm_after.bias''')						)
            rename_keys.append((F'''module.blocks.{i}.mlp.fc1.weight''', F'''vit.encoder.layer.{i}.intermediate.dense.weight''')						)
            rename_keys.append((F'''module.blocks.{i}.mlp.fc1.bias''', F'''vit.encoder.layer.{i}.intermediate.dense.bias''')						)
            rename_keys.append((F'''module.blocks.{i}.mlp.fc2.weight''', F'''vit.encoder.layer.{i}.output.dense.weight''')						)
            rename_keys.append((F'''module.blocks.{i}.mlp.fc2.bias''', F'''vit.encoder.layer.{i}.output.dense.bias''')						)

      # projection layer + position embeddings
      rename_keys.extend(
          [
              ('''module.cls_token''', '''vit.embeddings.cls_token'''),
              ('''module.patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight'''),
              ('''module.patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias'''),
              ('''module.pos_embed''', '''vit.embeddings.position_embeddings'''),
          ]						)

      if base_model:
            # layernorm + pooler
            rename_keys.extend(
                [
                    ('''module.norm.weight''', '''layernorm.weight'''),
                    ('''module.norm.bias''', '''layernorm.bias'''),
                ]						)

            # if just the base model, we should remove "vit" from all keys that start with "vit"
            a						:Any 							=       [(pair[0], pair[1][4:]) if pair[1].startswith('''vit'''						) else pair for pair in rename_keys]
      else:
            # layernorm + classification head
            rename_keys.extend(
                [
                    ('''norm.weight''', '''vit.layernorm.weight'''),
                    ('''norm.bias''', '''vit.layernorm.bias'''),
                    ('''head.weight''', '''classifier.weight'''),
                    ('''head.bias''', '''classifier.bias'''),
                ]						)

      return rename_keys
def 				__lowerCamelCase						( UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		Tuple ,  UpperCAmelCase_						:		Tuple=False						):




      """simple docstring"""





      for i in range(config.num_hidden_layers						):
            if base_model:
                  a						:Union[str, Any] 							=       ''''''
            else:
                  a						:Dict 							=       '''vit.'''
            # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
            a						:List[str] 							=       state_dict.pop(F'''module.blocks.{i}.attn.qkv.weight'''						)
            a						:Tuple 							=       state_dict.pop(F'''module.blocks.{i}.attn.qkv.bias'''						)
            # next, add query, keys and values (in that order) to the state dict
            a						:str 							=       in_proj_weight[
                : config.hidden_size, :
            ]
            a						:int 							=       in_proj_bias[: config.hidden_size]
            a						:Any 							=       in_proj_weight[
                config.hidden_size : config.hidden_size * 2, :
            ]
            a						:Dict 							=       in_proj_bias[
                config.hidden_size : config.hidden_size * 2
            ]
            a						:Optional[Any] 							=       in_proj_weight[
                -config.hidden_size :, :
            ]
            a						:Tuple 							=       in_proj_bias[-config.hidden_size :]
def 				__lowerCamelCase						( UpperCAmelCase_						:		Union[str, Any]						):




      """simple docstring"""





      a						:Any 							=       ['''head.weight''', '''head.bias''']
      for k in ignore_keys:
            state_dict.pop(__lowerCamelCase ,  __lowerCamelCase						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		List[str]						):




      """simple docstring"""





      a						:List[Any] 							=       [
          '''module.fc.fc1.weight''',
          '''module.fc.fc1.bias''',
          '''module.fc.bn1.weight''',
          '''module.fc.bn1.bias''',
          '''module.fc.bn1.running_mean''',
          '''module.fc.bn1.running_var''',
          '''module.fc.bn1.num_batches_tracked''',
          '''module.fc.fc2.weight''',
          '''module.fc.fc2.bias''',
          '''module.fc.bn2.weight''',
          '''module.fc.bn2.bias''',
          '''module.fc.bn2.running_mean''',
          '''module.fc.bn2.running_var''',
          '''module.fc.bn2.num_batches_tracked''',
          '''module.fc.fc3.weight''',
          '''module.fc.fc3.bias''',
      ]
      for k in ignore_keys:
            state_dict.pop(__lowerCamelCase ,  __lowerCamelCase						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		List[str] ,  UpperCAmelCase_						:		Dict ,  UpperCAmelCase_						:		Any						):




      """simple docstring"""





      a						:Any 							=       dct.pop(__lowerCamelCase						)
      a						:Union[str, Any] 							=       val
def 				__lowerCamelCase						( UpperCAmelCase_						:		str ,  UpperCAmelCase_						:		Optional[Any]						):




      """simple docstring"""





      a						:Union[str, Any] 							=       ViTMSNConfig()
      a						:int 							=       1000

      a						:List[str] 							=       '''datasets/huggingface/label-files'''
      a						:Optional[int] 							=       '''imagenet-1k-id2label.json'''
      a						:Optional[int] 							=       json.load(open(hf_hub_download(__lowerCamelCase ,  __lowerCamelCase						) ,  '''r'''						)						)
      a						:str 							=       {int(__lowerCamelCase						): v for k, v in idalabel.items()}
      a						:List[str] 							=       idalabel
      a						:List[Any] 							=       {v: k for k, v in idalabel.items()}

      if "s16" in checkpoint_url:
            a						:Optional[Any] 							=       384
            a						:Union[str, Any] 							=       1536
            a						:int 							=       6
      elif "l16" in checkpoint_url:
            a						:int 							=       1024
            a						:Dict 							=       4096
            a						:Tuple 							=       24
            a						:Any 							=       16
            a						:str 							=       0.1
      elif "b4" in checkpoint_url:
            a						:Optional[Any] 							=       4
      elif "l7" in checkpoint_url:
            a						:List[Any] 							=       7
            a						:int 							=       1024
            a						:Optional[int] 							=       4096
            a						:Union[str, Any] 							=       24
            a						:List[Any] 							=       16
            a						:Optional[int] 							=       0.1

      a						:List[str] 							=       ViTMSNModel(__lowerCamelCase						)

      a						:Tuple 							=       torch.hub.load_state_dict_from_url(__lowerCamelCase ,  map_location='''cpu'''						)['''target_encoder''']

      a						:List[str] 							=       ViTImageProcessor(size=config.image_size						)

      remove_projection_head(__lowerCamelCase						)
      a						:Any 							=       create_rename_keys(__lowerCamelCase ,  base_model=__lowerCamelCase						)

      for src, dest in rename_keys:
            rename_key(__lowerCamelCase ,  __lowerCamelCase ,  __lowerCamelCase						)
      read_in_q_k_v(__lowerCamelCase ,  __lowerCamelCase ,  base_model=__lowerCamelCase						)

      model.load_state_dict(__lowerCamelCase						)
      model.eval()

      a						:Dict 							=       '''http://images.cocodataset.org/val2017/000000039769.jpg'''

      a						:Optional[int] 							=       Image.open(requests.get(__lowerCamelCase ,  stream=__lowerCamelCase						).raw						)
      a						:Optional[Any] 							=       ViTImageProcessor(
          size=config.image_size ,  image_mean=__lowerCamelCase ,  image_std=__lowerCamelCase						)
      a						:Optional[int] 							=       image_processor(images=__lowerCamelCase ,  return_tensors='''pt'''						)

      # forward pass
      torch.manual_seed(2						)
      a						:List[Any] 							=       model(**__lowerCamelCase						)
      a						:Dict 							=       outputs.last_hidden_state

      # The following Colab Notebook was used to generate these outputs:
      # https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
      if "s16" in checkpoint_url:
            a						:Dict 							=       torch.tensor([[-1.0915, -1.4876, -1.1809]]						)
      elif "b16" in checkpoint_url:
            a						:Optional[Any] 							=       torch.tensor([[14.2889, -18.9045, 11.7281]]						)
      elif "l16" in checkpoint_url:
            a						:Optional[Any] 							=       torch.tensor([[41.5028, -22.8681, 45.6475]]						)
      elif "b4" in checkpoint_url:
            a						:Optional[int] 							=       torch.tensor([[-4.3868, 5.2932, -0.4137]]						)
      else:
            a						:Optional[int] 							=       torch.tensor([[-0.1792, -0.6465, 2.4263]]						)

      # verify logits
      assert torch.allclose(last_hidden_state[:, 0, :3] ,  __lowerCamelCase ,  atol=1E-4						)

      print(F'''Saving model to {pytorch_dump_folder_path}'''						)
      model.save_pretrained(__lowerCamelCase						)

      print(F'''Saving image processor to {pytorch_dump_folder_path}'''						)
      image_processor.save_pretrained(__lowerCamelCase						)


if __name__ == "__main__":
     snake_case				:    int       				=     argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '''--checkpoint_url''',
         default='''https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar''',
         type=str,
         help='''URL of the checkpoint you\'d like to convert.''',
     )
     parser.add_argument(
         '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
     )

     snake_case				:    int       				=     parser.parse_args()
     convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












'''simple docstring'''

import argparse
import logging
import pickle
from collections import Counter


logging.basicConfig(
    format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""", datefmt="""%m/%d/%Y %H:%M:%S""", level=logging.INFO
)
lowercase_					= logging.getLogger(__name__)

if __name__ == "__main__":
      lowercase_					= argparse.ArgumentParser(
          description="""Token Counts for smoothing the masking probabilities in MLM (cf XLM/word2vec)"""
      )
      parser.add_argument(
          """--data_file""", type=str, default="""data/dump.bert-base-uncased.pickle""", help="""The binarized dataset."""
      )
      parser.add_argument(
          """--token_counts_dump""", type=str, default="""data/token_counts.bert-base-uncased.pickle""", help="""The dump file."""
      )
      parser.add_argument("""--vocab_size""", default=30_522, type=int)
      lowercase_					= parser.parse_args()

      logger.info(f"""Loading data from {args.data_file}""")
      with open(args.data_file, """rb""") as fp:
            lowercase_					= pickle.load(fp)

      logger.info("""Counting occurrences for MLM.""")
      lowercase_					= Counter()
      for tk_ids in data:
            counter.update(tk_ids)
      lowercase_					= [0] * args.vocab_size
      for k, v in counter.items():
            lowercase_					= v

      logger.info(f"""Dump to {args.token_counts_dump}""")
      with open(args.token_counts_dump, """wb""") as handle:
            pickle.dump(counts, handle, protocol=pickle.HIGHEST_PROTOCOL)



