
"""simple docstring"""







from collections import defaultdict




def       A_      (       lowercase    ,			lowercase   )  ->				bool:


     """simple docstring"""







     UpperCAmelCase_    :     Optional[Any]            =	first_str.lower().strip()
     UpperCAmelCase_    :     str            =	second_str.lower().strip()

     # Remove whitespace
     UpperCAmelCase_    :     Tuple            =	first_str.replace(""" """    ,			""""""   )
     UpperCAmelCase_    :     Dict            =	second_str.replace(""" """    ,			""""""   )

     # Strings of different lengths are not anagrams
     if len(lowercase   ) != len(lowercase   ):
          return False

     # Default values for count should be 0
     UpperCAmelCase_    :     defaultdict[str, int]            =	defaultdict(lowercase   )

     # For each character in input strings,
     # increment count in the corresponding
     for i in range(len(lowercase   )   ):
          count[first_str[i]] += 1
          count[second_str[i]] -= 1

     return all(_count == 0 for _count in count.values()   )


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       lowercase_         =       input("Enter the first string ").strip()
       lowercase_         =       input("Enter the second string ").strip()

       lowercase_         =       check_anagrams(input_a, input_b)
       print(f"""{input_a} and {input_b} are {'' if status else 'not '}anagrams.""")



"""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       A_      (       lowercase    ,			lowercase=False   )  ->				Any:


     """simple docstring"""







     UpperCAmelCase_    :     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"
          UpperCAmelCase_    :     Union[str, 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    ,			lowercase    ,			lowercase=False   )  ->				Union[str, Any]:


     """simple docstring"""







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




def       A_      (       lowercase   )  ->				Dict:


     """simple docstring"""







     UpperCAmelCase_    :     List[Any]            =	["""head.weight""", """head.bias"""]
     for k in ignore_keys:
          state_dict.pop(lowercase    ,			lowercase   )




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


     """simple docstring"""







     UpperCAmelCase_    :     Optional[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(lowercase    ,			lowercase   )




def       A_      (       lowercase    ,			lowercase    ,			lowercase   )  ->				Any:


     """simple docstring"""







     UpperCAmelCase_    :     List[str]            =	dct.pop(lowercase   )
     UpperCAmelCase_    :     Dict            =	val




def       A_      (       lowercase    ,			lowercase   )  ->				Dict:


     """simple docstring"""







     UpperCAmelCase_    :     str            =	ViTMSNConfig()
     UpperCAmelCase_    :     List[str]            =	1000

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

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

     UpperCAmelCase_    :     Optional[Any]            =	ViTMSNModel(lowercase   )

     UpperCAmelCase_    :     str            =	torch.hub.load_state_dict_from_url(lowercase    ,			map_location="""cpu"""   )["""target_encoder"""]

     UpperCAmelCase_    :     Optional[Any]            =	ViTImageProcessor(size=config.image_size   )

     remove_projection_head(lowercase   )
     UpperCAmelCase_    :     List[str]            =	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()

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

     UpperCAmelCase_    :     Any            =	Image.open(requests.get(lowercase    ,			stream=lowercase   ).raw   )
     UpperCAmelCase_    :     int            =	ViTImageProcessor(
         size=config.image_size    ,			image_mean=lowercase    ,			image_std=lowercase   )
     UpperCAmelCase_    :     Tuple            =	image_processor(images=lowercase    ,			return_tensors="""pt"""   )

     # forward pass
     torch.manual_seed(2   )
     UpperCAmelCase_    :     int            =	model(**lowercase   )
     UpperCAmelCase_    :     str            =	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_    :     Optional[int]            =	torch.tensor([[-1.0915, -1.4876, -1.1809]]   )
     elif "b16" in checkpoint_url:
          UpperCAmelCase_    :     str            =	torch.tensor([[14.2889, -18.9045, 11.7281]]   )
     elif "l16" in checkpoint_url:
          UpperCAmelCase_    :     List[str]            =	torch.tensor([[41.5028, -22.8681, 45.6475]]   )
     elif "b4" in checkpoint_url:
          UpperCAmelCase_    :     Any            =	torch.tensor([[-4.3868, 5.2932, -0.4137]]   )
     else:
          UpperCAmelCase_    :     Dict            =	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__":
       lowercase_         =       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."
       )

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

