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     _a				(      lowercase__  :			Optional[int]     ,  lowercase__  :			List[str]=False ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		[]
     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__				:				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     _a				(      lowercase__  :			int     ,  lowercase__  :			Optional[Any]     ,  lowercase__  :			Optional[Any]=False ):







     '''simple docstring'''


     for i in range(config.num_hidden_layers ):
          if base_model:
               SCREAMING_SNAKE_CASE__				:				Any			=		''
          else:
               SCREAMING_SNAKE_CASE__				:				List[str]			=		'vit.'
          # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
          SCREAMING_SNAKE_CASE__				:				Any			=		state_dict.pop(f'''module.blocks.{i}.attn.qkv.weight''' )
          SCREAMING_SNAKE_CASE__				:				Tuple			=		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__				:				List[Any]			=		in_proj_weight[
              : config.hidden_size, :
          ]
          SCREAMING_SNAKE_CASE__				:				str			=		in_proj_bias[: config.hidden_size]
          SCREAMING_SNAKE_CASE__				:				List[str]			=		in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		in_proj_bias[
              config.hidden_size : config.hidden_size * 2
          ]
          SCREAMING_SNAKE_CASE__				:				int			=		in_proj_weight[
              -config.hidden_size :, :
          ]
          SCREAMING_SNAKE_CASE__				:				Dict			=		in_proj_bias[-config.hidden_size :]







def     _a				(      lowercase__  :			List[Any] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Optional[int]			=		['head.weight', 'head.bias']
     for k in ignore_keys:
          state_dict.pop(lowercase__     ,  lowercase__ )







def     _a				(      lowercase__  :			List[str] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Dict			=		[
         '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(lowercase__     ,  lowercase__ )







def     _a				(      lowercase__  :			str     ,  lowercase__  :			Optional[int]     ,  lowercase__  :			Optional[int] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				str			=		dct.pop(lowercase__ )
     SCREAMING_SNAKE_CASE__				:				Optional[int]			=		val







def     _a				(      lowercase__  :			List[str]     ,  lowercase__  :			List[Any] ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		ViTMSNConfig()
     SCREAMING_SNAKE_CASE__				:				int			=		10_00

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

     if "s16" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				int			=		3_84
          SCREAMING_SNAKE_CASE__				:				List[str]			=		15_36
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		6
     elif "l16" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		10_24
          SCREAMING_SNAKE_CASE__				:				List[str]			=		40_96
          SCREAMING_SNAKE_CASE__				:				Optional[int]			=		24
          SCREAMING_SNAKE_CASE__				:				int			=		16
          SCREAMING_SNAKE_CASE__				:				Tuple			=		0.1
     elif "b4" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				List[Any]			=		4
     elif "l7" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				int			=		7
          SCREAMING_SNAKE_CASE__				:				List[str]			=		10_24
          SCREAMING_SNAKE_CASE__				:				Any			=		40_96
          SCREAMING_SNAKE_CASE__				:				Dict			=		24
          SCREAMING_SNAKE_CASE__				:				Tuple			=		16
          SCREAMING_SNAKE_CASE__				:				int			=		0.1

     SCREAMING_SNAKE_CASE__				:				Optional[int]			=		ViTMSNModel(lowercase__ )

     SCREAMING_SNAKE_CASE__				:				Dict			=		torch.hub.load_state_dict_from_url(lowercase__     ,  map_location='cpu' )['target_encoder']

     SCREAMING_SNAKE_CASE__				:				Tuple			=		ViTImageProcessor(size=config.image_size )

     remove_projection_head(lowercase__ )
     SCREAMING_SNAKE_CASE__				:				Optional[int]			=		create_rename_keys(lowercase__     ,  base_model=lowercase__ )

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

     model.load_state_dict(lowercase__ )
     model.eval()

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

     SCREAMING_SNAKE_CASE__				:				str			=		Image.open(requests.get(lowercase__     ,  stream=lowercase__ ).raw )
     SCREAMING_SNAKE_CASE__				:				Dict			=		ViTImageProcessor(
         size=config.image_size     ,  image_mean=lowercase__     ,  image_std=lowercase__ )
     SCREAMING_SNAKE_CASE__				:				Tuple			=		image_processor(images=lowercase__     ,  return_tensors='pt' )

     # forward pass
     torch.manual_seed(2 )
     SCREAMING_SNAKE_CASE__				:				str			=		model(**lowercase__ )
     SCREAMING_SNAKE_CASE__				:				Tuple			=		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__				:				Dict			=		torch.tensor([[-1.0915, -1.4876, -1.1809]] )
     elif "b16" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		torch.tensor([[14.2889, -18.9045, 11.7281]] )
     elif "l16" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				Any			=		torch.tensor([[41.5028, -22.8681, 45.6475]] )
     elif "b4" in checkpoint_url:
          SCREAMING_SNAKE_CASE__				:				str			=		torch.tensor([[-4.3868, 5.2932, -0.4137]] )
     else:
          SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		torch.tensor([[-0.1792, -0.6465, 2.4263]] )

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

     print(f'''Saving model to {pytorch_dump_folder_path}''' )
     model.save_pretrained(lowercase__ )

     print(f'''Saving image processor to {pytorch_dump_folder_path}''' )
     image_processor.save_pretrained(lowercase__ )


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE__		:					List[Any]						=					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."
      )

      SCREAMING_SNAKE_CASE__		:					List[Any]						=					parser.parse_args()
      convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)




def     _a				(      lowercase__  :			int     ,  lowercase__  :			int ):







     '''simple docstring'''


     return int((input_a, input_a).count(0 ) != 0 )







def     _a				(      ):







     '''simple docstring'''


     assert nand_gate(0     ,  0 ) == 1
     assert nand_gate(0     ,  1 ) == 1
     assert nand_gate(1     ,  0 ) == 1
     assert nand_gate(1     ,  1 ) == 0


if __name__ == "__main__":
      print(nand_gate(0, 0))
      print(nand_gate(0, 1))
      print(nand_gate(1, 0))
      print(nand_gate(1, 1))



