





'''simple docstring'''




import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor






def 	_lowerCAmelCase      (  __snake_case  :			Dict      )					->					Optional[Any]:
     if "cls_token" in name:
          __A						:			Dict								=	name.replace('cls_token'			,							'vit.embeddings.cls_token'      )
     if "mask_token" in name:
          __A						:			int								=	name.replace('mask_token'			,							'decoder.mask_token'      )
     if "decoder_pos_embed" in name:
          __A						:			List[Any]								=	name.replace('decoder_pos_embed'			,							'decoder.decoder_pos_embed'      )
     if "pos_embed" in name and "decoder" not in name:
          __A						:			Union[str, Any]								=	name.replace('pos_embed'			,							'vit.embeddings.position_embeddings'      )
     if "patch_embed.proj" in name:
          __A						:			Tuple								=	name.replace('patch_embed.proj'			,							'vit.embeddings.patch_embeddings.projection'      )
     if "patch_embed.norm" in name:
          __A						:			List[str]								=	name.replace('patch_embed.norm'			,							'vit.embeddings.norm'      )
     if "decoder_blocks" in name:
          __A						:			Dict								=	name.replace('decoder_blocks'			,							'decoder.decoder_layers'      )
     if "blocks" in name:
          __A						:			Dict								=	name.replace('blocks'			,							'vit.encoder.layer'      )
     if "attn.proj" in name:
          __A						:			Tuple								=	name.replace('attn.proj'			,							'attention.output.dense'      )
     if "attn" in name:
          __A						:			List[str]								=	name.replace('attn'			,							'attention.self'      )
     if "norm1" in name:
          __A						:			Dict								=	name.replace('norm1'			,							'layernorm_before'      )
     if "norm2" in name:
          __A						:			Any								=	name.replace('norm2'			,							'layernorm_after'      )
     if "mlp.fc1" in name:
          __A						:			Optional[int]								=	name.replace('mlp.fc1'			,							'intermediate.dense'      )
     if "mlp.fc2" in name:
          __A						:			Dict								=	name.replace('mlp.fc2'			,							'output.dense'      )
     if "decoder_embed" in name:
          __A						:			int								=	name.replace('decoder_embed'			,							'decoder.decoder_embed'      )
     if "decoder_norm" in name:
          __A						:			List[Any]								=	name.replace('decoder_norm'			,							'decoder.decoder_norm'      )
     if "decoder_pred" in name:
          __A						:			str								=	name.replace('decoder_pred'			,							'decoder.decoder_pred'      )
     if "norm.weight" in name and "decoder" not in name:
          __A						:			Optional[int]								=	name.replace('norm.weight'			,							'vit.layernorm.weight'      )
     if "norm.bias" in name and "decoder" not in name:
          __A						:			int								=	name.replace('norm.bias'			,							'vit.layernorm.bias'      )

     return name






def 	_lowerCAmelCase      (  __snake_case  :			Union[str, Any]			,							__snake_case  :			Any      )					->					Tuple:
     for key in orig_state_dict.copy().keys():
          __A						:			Tuple								=	orig_state_dict.pop(__snake_case      )

          if "qkv" in key:
               __A						:			Optional[Any]								=	key.split('.'      )
               __A						:			Dict								=	int(key_split[1]      )
               if "decoder_blocks" in key:
                    __A						:			List[Any]								=	config.decoder_hidden_size
                    __A						:			Tuple								=	'decoder.decoder_layers.'
                    if "weight" in key:
                         __A						:			Tuple								=	val[:dim, :]
                         __A						:			List[Any]								=	val[dim : dim * 2, :]
                         __A						:			int								=	val[-dim:, :]
                    elif "bias" in key:
                         __A						:			Optional[int]								=	val[:dim]
                         __A						:			int								=	val[dim : dim * 2]
                         __A						:			List[str]								=	val[-dim:]
               else:
                    __A						:			Optional[int]								=	config.hidden_size
                    __A						:			int								=	'vit.encoder.layer.'
                    if "weight" in key:
                         __A						:			Optional[int]								=	val[:dim, :]
                         __A						:			Any								=	val[dim : dim * 2, :]
                         __A						:			int								=	val[-dim:, :]
                    elif "bias" in key:
                         __A						:			Optional[Any]								=	val[:dim]
                         __A						:			Optional[int]								=	val[dim : dim * 2]
                         __A						:			Optional[int]								=	val[-dim:]

          else:
               __A						:			Optional[int]								=	val

     return orig_state_dict






def 	_lowerCAmelCase      (  __snake_case  :			Optional[Any]			,							__snake_case  :			str      )					->					Dict:
     __A						:			Any								=	ViTMAEConfig()
     if "large" in checkpoint_url:
          __A						:			int								=	10_24
          __A						:			List[str]								=	40_96
          __A						:			Any								=	24
          __A						:			Union[str, Any]								=	16
     elif "huge" in checkpoint_url:
          __A						:			int								=	14
          __A						:			Dict								=	12_80
          __A						:			List[Any]								=	51_20
          __A						:			Dict								=	32
          __A						:			str								=	16

     __A						:			Union[str, Any]								=	ViTMAEForPreTraining(__snake_case      )

     __A						:			List[str]								=	torch.hub.load_state_dict_from_url(__snake_case			,							map_location='cpu'      )['model']

     __A						:			int								=	ViTMAEImageProcessor(size=config.image_size      )

     __A						:			Any								=	convert_state_dict(__snake_case			,							__snake_case      )

     model.load_state_dict(__snake_case      )
     model.eval()

     __A						:			Union[str, Any]								=	'https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg'

     __A						:			int								=	Image.open(requests.get(__snake_case			,							stream=__snake_case      ).raw      )
     __A						:			Union[str, Any]								=	ViTMAEImageProcessor(size=config.image_size      )
     __A						:			Union[str, Any]								=	image_processor(images=__snake_case			,							return_tensors='pt'      )

     # forward pass
     torch.manual_seed(2      )
     __A						:			Union[str, Any]								=	model(**__snake_case      )
     __A						:			List[str]								=	outputs.logits

     if "large" in checkpoint_url:
          __A						:			List[str]								=	torch.tensor(
              [[-0.7_309, -0.7_128, -1.0_169], [-1.0_161, -0.9_058, -1.1_878], [-1.0_478, -0.9_411, -1.1_911]]      )
     elif "huge" in checkpoint_url:
          __A						:			str								=	torch.tensor(
              [[-1.1_599, -0.9_199, -1.2_221], [-1.1_952, -0.9_269, -1.2_307], [-1.2_143, -0.9_337, -1.2_262]]      )
     else:
          __A						:			List[str]								=	torch.tensor(
              [[-0.9_192, -0.8_481, -1.1_259], [-1.1_349, -1.0_034, -1.2_599], [-1.1_757, -1.0_429, -1.2_726]]      )

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

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

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


if __name__ == "__main__":
  lowercase__   :				Union[str, Any]      =   argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--checkpoint_url''',
      default='''https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth''',
      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__   :				Optional[Any]      =   parser.parse_args()
  convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






'''simple docstring'''




import math






def 	_lowerCAmelCase      (  __snake_case  :			int      )					->					bool:

     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5			,							int(math.sqrt(__snake_case      ) + 1      )			,							6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True






def 	_lowerCAmelCase      (  __snake_case  :			float = 0.1      )					->					int:
     __A						:			Dict								=	3
     __A						:			int								=	3

     while primes / (2 * j - 1) >= ratio:
          for i in range(j * j + j + 1			,							(j + 2) * (j + 2)			,							j + 1      ):
               primes += is_prime(__snake_case      )
          j += 2
     return j


if __name__ == "__main__":
  import doctest

  doctest.testmod()