

"""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       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase=False		):







       '''simple docstring'''
       UpperCAmelCase	    =			[]
       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"
              UpperCAmelCase	    =			[(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       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase=False		):







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






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			["""head.weight""", """head.bias"""]
       for k in ignore_keys:
              state_dict.pop(lowerCAmelCase	,      lowerCAmelCase		)






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			[
           """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       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			dct.pop(lowerCAmelCase		)
       UpperCAmelCase	    =			val






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			ViTMSNConfig()
       UpperCAmelCase	    =			1000

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

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

       UpperCAmelCase	    =			ViTMSNModel(lowerCAmelCase		)

       UpperCAmelCase	    =			torch.hub.load_state_dict_from_url(lowerCAmelCase	,      map_location="""cpu"""		)["""target_encoder"""]

       UpperCAmelCase	    =			ViTImageProcessor(size=config.image_size		)

       remove_projection_head(lowerCAmelCase		)
       UpperCAmelCase	    =			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()

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

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

       # forward pass
       torch.manual_seed(2		)
       UpperCAmelCase	    =			model(**lowerCAmelCase		)
       UpperCAmelCase	    =			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:
              UpperCAmelCase	    =			torch.tensor([[-1.09_15, -1.48_76, -1.18_09]]		)
       elif "b16" in checkpoint_url:
              UpperCAmelCase	    =			torch.tensor([[14.28_89, -18.90_45, 11.72_81]]		)
       elif "l16" in checkpoint_url:
              UpperCAmelCase	    =			torch.tensor([[41.50_28, -22.86_81, 45.64_75]]		)
       elif "b4" in checkpoint_url:
              UpperCAmelCase	    =			torch.tensor([[-4.38_68, 5.29_32, -0.41_37]]		)
       else:
              UpperCAmelCase	    =			torch.tensor([[-0.17_92, -0.64_65, 2.42_63]]		)

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

 lowerCAmelCase_	:    Dict            =      parser.parse_args()
 convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








"""simple docstring"""







def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			0
       UpperCAmelCase	    =			len(lowerCAmelCase		)

       for i in range(n - 1		):
              for j in range(i + 1	,      lowerCAmelCase		):
                     if arr[i] > arr[j]:
                            num_inversions += 1

       return num_inversions






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       if len(lowerCAmelCase		) <= 1:
              return arr, 0
       UpperCAmelCase	    =			len(lowerCAmelCase		) // 2
       UpperCAmelCase	    =			arr[0:mid]
       UpperCAmelCase	    =			arr[mid:]

       UpperCAmelCase    ,       UpperCAmelCase	    =			count_inversions_recursive(lowerCAmelCase		)
       UpperCAmelCase    ,       UpperCAmelCase	    =			count_inversions_recursive(lowerCAmelCase		)
       UpperCAmelCase    ,       UpperCAmelCase	    =			_count_cross_inversions(lowerCAmelCase	,      lowerCAmelCase		)

       UpperCAmelCase	    =			inversion_p + inversions_q + cross_inversions
       return c, num_inversions






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			[]
       UpperCAmelCase	    =			UpperCAmelCase	    =			UpperCAmelCase	    =			0
       while i < len(lowerCAmelCase		) and j < len(lowerCAmelCase		):
              if p[i] > q[j]:
                     # if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
                     # These are all inversions. The claim emerges from the
                     # property that P is sorted.
                     num_inversion += len(lowerCAmelCase		) - i
                     r.append(q[j]		)
                     j += 1
              else:
                     r.append(p[i]		)
                     i += 1

       if i < len(lowerCAmelCase		):
              r.extend(p[i:]		)
       else:
              r.extend(q[j:]		)

       return r, num_inversion






def       _lowerCAmelCase       (      ):







       '''simple docstring'''
       UpperCAmelCase	    =			[10, 2, 1, 5, 5, 2, 11]

       # this arr has 8 inversions:
       # (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

       UpperCAmelCase	    =			count_inversions_bf(lowerCAmelCase		)
       UpperCAmelCase    ,       UpperCAmelCase	    =			count_inversions_recursive(lowerCAmelCase		)

       assert num_inversions_bf == num_inversions_recursive == 8

       print("""number of inversions = """	,      lowerCAmelCase		)

       # testing an array with zero inversion (a sorted arr_1)

       arr_a.sort()
       UpperCAmelCase	    =			count_inversions_bf(lowerCAmelCase		)
       UpperCAmelCase    ,       UpperCAmelCase	    =			count_inversions_recursive(lowerCAmelCase		)

       assert num_inversions_bf == num_inversions_recursive == 0
       print("""number of inversions = """	,      lowerCAmelCase		)

       # an empty list should also have zero inversions
       UpperCAmelCase	    =			[]
       UpperCAmelCase	    =			count_inversions_bf(lowerCAmelCase		)
       UpperCAmelCase    ,       UpperCAmelCase	    =			count_inversions_recursive(lowerCAmelCase		)

       assert num_inversions_bf == num_inversions_recursive == 0
       print("""number of inversions = """	,      lowerCAmelCase		)


if __name__ == "__main__":
 main()
