





'''simple docstring'''

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 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase=False      )						->					str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       []
   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"
      __SCREAMING_SNAKE_CASE      							=       [(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 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase=False      )						->					Dict:

   '''simple docstring'''







   for i in range(config.num_hidden_layers      ):
      if base_model:
         __SCREAMING_SNAKE_CASE      							=       """"""
      else:
         __SCREAMING_SNAKE_CASE      							=       """vit."""
      # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
      __SCREAMING_SNAKE_CASE      							=       state_dict.pop(f"""module.blocks.{i}.attn.qkv.weight"""      )
      __SCREAMING_SNAKE_CASE      							=       state_dict.pop(f"""module.blocks.{i}.attn.qkv.bias"""      )
      # next, add query, keys and values (in that order) to the state dict
      __SCREAMING_SNAKE_CASE      							=       in_proj_weight[
          : config.hidden_size, :
      ]
      __SCREAMING_SNAKE_CASE      							=       in_proj_bias[: config.hidden_size]
      __SCREAMING_SNAKE_CASE      							=       in_proj_weight[
          config.hidden_size : config.hidden_size * 2, :
      ]
      __SCREAMING_SNAKE_CASE      							=       in_proj_bias[
          config.hidden_size : config.hidden_size * 2
      ]
      __SCREAMING_SNAKE_CASE      							=       in_proj_weight[
          -config.hidden_size :, :
      ]
      __SCREAMING_SNAKE_CASE      							=       in_proj_bias[-config.hidden_size :]

def 						__magic_name__       (							__UpperCAmelCase      )						->					int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       ["""head.weight""", """head.bias"""]
   for k in ignore_keys:
      state_dict.pop(__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase      )						->					int:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       [
       """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(__UpperCAmelCase							,	__UpperCAmelCase      )

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase							,	__UpperCAmelCase      )						->					Dict:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       dct.pop(__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       val

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					Dict:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       ViTMSNConfig()
   __SCREAMING_SNAKE_CASE      							=       1000

   __SCREAMING_SNAKE_CASE      							=       """datasets/huggingface/label-files"""
   __SCREAMING_SNAKE_CASE      							=       """imagenet-1k-id2label.json"""
   __SCREAMING_SNAKE_CASE      							=       json.load(open(hf_hub_download(__UpperCAmelCase							,	__UpperCAmelCase      )							,	"""r"""      )      )
   __SCREAMING_SNAKE_CASE      							=       {int(__UpperCAmelCase      ): v for k, v in idalabel.items()}
   __SCREAMING_SNAKE_CASE      							=       idalabel
   __SCREAMING_SNAKE_CASE      							=       {v: k for k, v in idalabel.items()}

   if "s16" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       384
      __SCREAMING_SNAKE_CASE      							=       1536
      __SCREAMING_SNAKE_CASE      							=       6
   elif "l16" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       1024
      __SCREAMING_SNAKE_CASE      							=       4096
      __SCREAMING_SNAKE_CASE      							=       24
      __SCREAMING_SNAKE_CASE      							=       16
      __SCREAMING_SNAKE_CASE      							=       0.1
   elif "b4" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       4
   elif "l7" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       7
      __SCREAMING_SNAKE_CASE      							=       1024
      __SCREAMING_SNAKE_CASE      							=       4096
      __SCREAMING_SNAKE_CASE      							=       24
      __SCREAMING_SNAKE_CASE      							=       16
      __SCREAMING_SNAKE_CASE      							=       0.1

   __SCREAMING_SNAKE_CASE      							=       ViTMSNModel(__UpperCAmelCase      )

   __SCREAMING_SNAKE_CASE      							=       torch.hub.load_state_dict_from_url(__UpperCAmelCase							,	map_location="""cpu"""      )["""target_encoder"""]

   __SCREAMING_SNAKE_CASE      							=       ViTImageProcessor(size=config.image_size      )

   remove_projection_head(__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       create_rename_keys(__UpperCAmelCase							,	base_model=__UpperCAmelCase      )

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

   model.load_state_dict(__UpperCAmelCase      )
   model.eval()

   __SCREAMING_SNAKE_CASE      							=       """http://images.cocodataset.org/val2017/000000039769.jpg"""

   __SCREAMING_SNAKE_CASE      							=       Image.open(requests.get(__UpperCAmelCase							,	stream=__UpperCAmelCase      ).raw      )
   __SCREAMING_SNAKE_CASE      							=       ViTImageProcessor(
       size=config.image_size							,	image_mean=__UpperCAmelCase							,	image_std=__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       image_processor(images=__UpperCAmelCase							,	return_tensors="""pt"""      )

   # forward pass
   torch.manual_seed(2      )
   __SCREAMING_SNAKE_CASE      							=       model(**__UpperCAmelCase      )
   __SCREAMING_SNAKE_CASE      							=       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:
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([[-1.0_9_1_5, -1.4_8_7_6, -1.1_8_0_9]]      )
   elif "b16" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([[1_4.2_8_8_9, -1_8.9_0_4_5, 1_1.7_2_8_1]]      )
   elif "l16" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([[4_1.5_0_2_8, -2_2.8_6_8_1, 4_5.6_4_7_5]]      )
   elif "b4" in checkpoint_url:
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([[-4.3_8_6_8, 5.2_9_3_2, -0.4_1_3_7]]      )
   else:
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([[-0.1_7_9_2, -0.6_4_6_5, 2.4_2_6_3]]      )

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

   print(f"""Saving model to {pytorch_dump_folder_path}"""      )
   model.save_pretrained(__UpperCAmelCase      )

   print(f"""Saving image processor to {pytorch_dump_folder_path}"""      )
   image_processor.save_pretrained(__UpperCAmelCase      )


if __name__ == "__main__":
    a        =						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."
    )

    a        =						parser.parse_args()
    convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












'''simple docstring'''

import os
import string
import sys


a        =						1 << 8

a        =						{
    "tab": ord("\t"),
    "newline": ord("\r"),
    "esc": 27,
    "up": 65 + ARROW_KEY_FLAG,
    "down": 66 + ARROW_KEY_FLAG,
    "right": 67 + ARROW_KEY_FLAG,
    "left": 68 + ARROW_KEY_FLAG,
    "mod_int": 91,
    "undefined": sys.maxsize,
    "interrupt": 3,
    "insert": 50,
    "delete": 51,
    "pg_up": 53,
    "pg_down": 54,
}

a        =						KEYMAP["up"]
a        =						KEYMAP["left"]

if sys.platform == "win32":
    a        =						[]
    a        =						{
        b"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
        b"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
    }

for i in range(10):
    a        =						ord(str(i))

def 						__magic_name__       (							)						->					Union[str, Any]:

   '''simple docstring'''







   if os.name == "nt":
      import msvcrt

      __SCREAMING_SNAKE_CASE      							=       """mbcs"""
      # Flush the keyboard buffer
      while msvcrt.kbhit():
         msvcrt.getch()
      if len(__UpperCAmelCase      ) == 0:
         # Read the keystroke
         __SCREAMING_SNAKE_CASE      							=       msvcrt.getch()

         # If it is a prefix char, get second part
         if ch in (b"\x00", b"\xe0"):
            __SCREAMING_SNAKE_CASE      							=       ch + msvcrt.getch()
            # Translate actual Win chars to bullet char types
            try:
               __SCREAMING_SNAKE_CASE      							=       chr(WIN_KEYMAP[cha]      )
               WIN_CH_BUFFER.append(chr(KEYMAP["""mod_int"""]      )      )
               WIN_CH_BUFFER.append(__UpperCAmelCase      )
               if ord(__UpperCAmelCase      ) in (
                   KEYMAP["insert"] - 1 << 9,
                   KEYMAP["delete"] - 1 << 9,
                   KEYMAP["pg_up"] - 1 << 9,
                   KEYMAP["pg_down"] - 1 << 9,
               ):
                  WIN_CH_BUFFER.append(chr(126      )      )
               __SCREAMING_SNAKE_CASE      							=       chr(KEYMAP["""esc"""]      )
            except KeyError:
               __SCREAMING_SNAKE_CASE      							=       cha[1]
         else:
            __SCREAMING_SNAKE_CASE      							=       ch.decode(__UpperCAmelCase      )
      else:
         __SCREAMING_SNAKE_CASE      							=       WIN_CH_BUFFER.pop(0      )
   elif os.name == "posix":
      import termios
      import tty

      __SCREAMING_SNAKE_CASE      							=       sys.stdin.fileno()
      __SCREAMING_SNAKE_CASE      							=       termios.tcgetattr(__UpperCAmelCase      )
      try:
         tty.setraw(__UpperCAmelCase      )
         __SCREAMING_SNAKE_CASE      							=       sys.stdin.read(1      )
      finally:
         termios.tcsetattr(__UpperCAmelCase							,	termios.TCSADRAIN							,	__UpperCAmelCase      )
   return ch







def 						__magic_name__       (							)						->					List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
   if ord(__UpperCAmelCase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
      return char

   elif ord(__UpperCAmelCase      ) == KEYMAP["esc"]:
      __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
      if ord(__UpperCAmelCase      ) == KEYMAP["mod_int"]:
         __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
         if ord(__UpperCAmelCase      ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(__UpperCAmelCase      ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
            return chr(ord(__UpperCAmelCase      ) + ARROW_KEY_FLAG      )
         else:
            return KEYMAP["undefined"]
      else:
         return get_raw_chars()

   else:
      if char in string.printable:
         return char
      else:
         return KEYMAP["undefined"]





