






import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor





def       __lowerCAmelCase      (						__snake_case       ):
     if "cls_token" in name:
          __lowerCAmelCase								=					name.replace("cls_token"					, "vit.embeddings.cls_token"       )
     if "mask_token" in name:
          __lowerCAmelCase								=					name.replace("mask_token"					, "decoder.mask_token"       )
     if "decoder_pos_embed" in name:
          __lowerCAmelCase								=					name.replace("decoder_pos_embed"					, "decoder.decoder_pos_embed"       )
     if "pos_embed" in name and "decoder" not in name:
          __lowerCAmelCase								=					name.replace("pos_embed"					, "vit.embeddings.position_embeddings"       )
     if "patch_embed.proj" in name:
          __lowerCAmelCase								=					name.replace("patch_embed.proj"					, "vit.embeddings.patch_embeddings.projection"       )
     if "patch_embed.norm" in name:
          __lowerCAmelCase								=					name.replace("patch_embed.norm"					, "vit.embeddings.norm"       )
     if "decoder_blocks" in name:
          __lowerCAmelCase								=					name.replace("decoder_blocks"					, "decoder.decoder_layers"       )
     if "blocks" in name:
          __lowerCAmelCase								=					name.replace("blocks"					, "vit.encoder.layer"       )
     if "attn.proj" in name:
          __lowerCAmelCase								=					name.replace("attn.proj"					, "attention.output.dense"       )
     if "attn" in name:
          __lowerCAmelCase								=					name.replace("attn"					, "attention.self"       )
     if "norm1" in name:
          __lowerCAmelCase								=					name.replace("norm1"					, "layernorm_before"       )
     if "norm2" in name:
          __lowerCAmelCase								=					name.replace("norm2"					, "layernorm_after"       )
     if "mlp.fc1" in name:
          __lowerCAmelCase								=					name.replace("mlp.fc1"					, "intermediate.dense"       )
     if "mlp.fc2" in name:
          __lowerCAmelCase								=					name.replace("mlp.fc2"					, "output.dense"       )
     if "decoder_embed" in name:
          __lowerCAmelCase								=					name.replace("decoder_embed"					, "decoder.decoder_embed"       )
     if "decoder_norm" in name:
          __lowerCAmelCase								=					name.replace("decoder_norm"					, "decoder.decoder_norm"       )
     if "decoder_pred" in name:
          __lowerCAmelCase								=					name.replace("decoder_pred"					, "decoder.decoder_pred"       )
     if "norm.weight" in name and "decoder" not in name:
          __lowerCAmelCase								=					name.replace("norm.weight"					, "vit.layernorm.weight"       )
     if "norm.bias" in name and "decoder" not in name:
          __lowerCAmelCase								=					name.replace("norm.bias"					, "vit.layernorm.bias"       )

     return name





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     for key in orig_state_dict.copy().keys():
          __lowerCAmelCase								=					orig_state_dict.pop(__snake_case       )

          if "qkv" in key:
               __lowerCAmelCase								=					key.split("."       )
               __lowerCAmelCase								=					int(key_split[1]       )
               if "decoder_blocks" in key:
                    __lowerCAmelCase								=					config.decoder_hidden_size
                    __lowerCAmelCase								=					"decoder.decoder_layers."
                    if "weight" in key:
                         __lowerCAmelCase								=					val[:dim, :]
                         __lowerCAmelCase								=					val[dim : dim * 2, :]
                         __lowerCAmelCase								=					val[-dim:, :]
                    elif "bias" in key:
                         __lowerCAmelCase								=					val[:dim]
                         __lowerCAmelCase								=					val[dim : dim * 2]
                         __lowerCAmelCase								=					val[-dim:]
               else:
                    __lowerCAmelCase								=					config.hidden_size
                    __lowerCAmelCase								=					"vit.encoder.layer."
                    if "weight" in key:
                         __lowerCAmelCase								=					val[:dim, :]
                         __lowerCAmelCase								=					val[dim : dim * 2, :]
                         __lowerCAmelCase								=					val[-dim:, :]
                    elif "bias" in key:
                         __lowerCAmelCase								=					val[:dim]
                         __lowerCAmelCase								=					val[dim : dim * 2]
                         __lowerCAmelCase								=					val[-dim:]

          else:
               __lowerCAmelCase								=					val

     return orig_state_dict





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     __lowerCAmelCase								=					ViTMAEConfig()
     if "large" in checkpoint_url:
          __lowerCAmelCase								=					1024
          __lowerCAmelCase								=					4096
          __lowerCAmelCase								=					24
          __lowerCAmelCase								=					16
     elif "huge" in checkpoint_url:
          __lowerCAmelCase								=					14
          __lowerCAmelCase								=					1280
          __lowerCAmelCase								=					5120
          __lowerCAmelCase								=					32
          __lowerCAmelCase								=					16

     __lowerCAmelCase								=					ViTMAEForPreTraining(__snake_case       )

     __lowerCAmelCase								=					torch.hub.load_state_dict_from_url(__snake_case					, map_location="cpu"       )["model"]

     __lowerCAmelCase								=					ViTMAEImageProcessor(size=config.image_size       )

     __lowerCAmelCase								=					convert_state_dict(__snake_case					, __snake_case       )

     model.load_state_dict(__snake_case       )
     model.eval()

     __lowerCAmelCase								=					"https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg"

     __lowerCAmelCase								=					Image.open(requests.get(__snake_case					, stream=__snake_case       ).raw       )
     __lowerCAmelCase								=					ViTMAEImageProcessor(size=config.image_size       )
     __lowerCAmelCase								=					image_processor(images=__snake_case					, return_tensors="pt"       )

     # forward pass
     torch.manual_seed(2       )
     __lowerCAmelCase								=					model(**__snake_case       )
     __lowerCAmelCase								=					outputs.logits

     if "large" in checkpoint_url:
          __lowerCAmelCase								=					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:
          __lowerCAmelCase								=					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:
          __lowerCAmelCase								=					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__":
 lowerCamelCase			:					Optional[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.'''
 )

 lowerCamelCase			:					Optional[Any]         =	parser.parse_args()
 convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)














def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     if not isinstance(__snake_case					, __snake_case       ):
          raise ValueError("iterations must be defined as integers"       )
     if not isinstance(__snake_case					, __snake_case       ) or not number >= 1:
          raise ValueError(
              "starting number must be\n                         and integer and be more than 0"       )
     if not iterations >= 1:
          raise ValueError("Iterations must be done more than 0 times to play FizzBuzz"       )

     __lowerCAmelCase								=					""
     while number <= iterations:
          if number % 3 == 0:
               out += "Fizz"
          if number % 5 == 0:
               out += "Buzz"
          if 0 not in (number % 3, number % 5):
               out += str(__snake_case       )

          # print(out)
          number += 1
          out += " "
     return out


if __name__ == "__main__":
 import doctest

 doctest.testmod()






