




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 SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_=False						)       ->	Optional[int]:



       """simple docstring"""

       A__							=   []
       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__							=   [(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 SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_			,    lowercase_=False						)       ->	int:



       """simple docstring"""

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







def SCREAMING_SNAKE_CASE    (	lowercase_						)       ->	Tuple:



       """simple docstring"""

       A__							=   ['''head.weight''', '''head.bias''']
       for k in ignore_keys:
              state_dict.pop(_UpperCamelCase			,    _UpperCamelCase						)







def SCREAMING_SNAKE_CASE    (	lowercase_						)       ->	List[str]:



       """simple docstring"""

       A__							=   [
           '''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 SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_			,    lowercase_						)       ->	Optional[Any]:



       """simple docstring"""

       A__							=   dct.pop(_UpperCamelCase						)
       A__							=   val







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



       """simple docstring"""

       A__							=   ViTMSNConfig()
       A__							=   1_000

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

       if "s16" in checkpoint_url:
              A__							=   384
              A__							=   1_536
              A__							=   6
       elif "l16" in checkpoint_url:
              A__							=   1_024
              A__							=   4_096
              A__							=   24
              A__							=   16
              A__							=   0.1
       elif "b4" in checkpoint_url:
              A__							=   4
       elif "l7" in checkpoint_url:
              A__							=   7
              A__							=   1_024
              A__							=   4_096
              A__							=   24
              A__							=   16
              A__							=   0.1

       A__							=   ViTMSNModel(_UpperCamelCase						)

       A__							=   torch.hub.load_state_dict_from_url(_UpperCamelCase			,    map_location='''cpu'''						)['''target_encoder''']

       A__							=   ViTImageProcessor(size=config.image_size						)

       remove_projection_head(_UpperCamelCase						)
       A__							=   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()

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

       A__							=   Image.open(requests.get(_UpperCamelCase			,    stream=_UpperCamelCase						).raw						)
       A__							=   ViTImageProcessor(
           size=config.image_size			,    image_mean=_UpperCamelCase			,    image_std=_UpperCamelCase						)
       A__							=   image_processor(images=_UpperCamelCase			,    return_tensors='''pt'''						)

       # forward pass
       torch.manual_seed(2						)
       A__							=   model(**_UpperCamelCase						)
       A__							=   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__							=   torch.tensor([[-1.09_15, -1.48_76, -1.18_09]]						)
       elif "b16" in checkpoint_url:
              A__							=   torch.tensor([[14.2_889, -18.9_045, 11.7_281]]						)
       elif "l16" in checkpoint_url:
              A__							=   torch.tensor([[41.5_028, -22.8_681, 45.6_475]]						)
       elif "b4" in checkpoint_url:
              A__							=   torch.tensor([[-4.38_68, 5.29_32, -0.41_37]]						)
       else:
              A__							=   torch.tensor([[-0.17_92, -0.64_65, 2.42_63]]						)

       # 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__":
  _lowerCamelCase     :		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."""
  )

  _lowerCamelCase     :		Any								=	parser.parse_args()
  convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








_lowerCamelCase     :		dict[str, float]								=       {
    "km/h": 1.0,
    "m/s": 3.6,
    "mph": 1.609_344,
    "knot": 1.852,
}

_lowerCamelCase     :		dict[str, float]								=       {
    "km/h": 1.0,
    "m/s": 0.277_777_778,
    "mph": 0.621_371_192,
    "knot": 0.539_956_803,
}







def SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_			,    lowercase_						)       ->	float:



       """simple docstring"""

       if unit_to not in speed_chart or unit_from not in speed_chart_inverse:
              A__							=   (
                  f"""Incorrect 'from_type' or 'to_type' value: {unit_from!r}, {unit_to!r}\n"""
                  f"""Valid values are: {", ".join(lowercase_						)}"""
              )
              raise ValueError(lowercase_						)
       return round(speed * speed_chart[unit_from] * speed_chart_inverse[unit_to]			,    3						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()


