
"""simple docstring"""





import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor
def 							A_     (__a				):

					'''simple docstring'''





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

					return name
def 							A_     (__a				,   __a				):

					'''simple docstring'''





					for key in orig_state_dict.copy().keys():
										A_				 =						orig_state_dict.pop(__a				)

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

										else:
															A_				 =						val

					return orig_state_dict
def 							A_     (__a				,   __a				):

					'''simple docstring'''





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

					A_				 =						ViTMAEForPreTraining(__a				)

					A_				 =						torch.hub.load_state_dict_from_url(__a				,   map_location="cpu"				)["model"]

					A_				 =						ViTMAEImageProcessor(size=config.image_size				)

					A_				 =						convert_state_dict(__a				,   __a				)

					model.load_state_dict(__a				)
					model.eval()

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

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

					# forward pass
					torch.manual_seed(2				)
					A_				 =						model(**__a				)
					A_				 =						outputs.logits

					if "large" in checkpoint_url:
										A_				 =						torch.tensor(
										    [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]]				)
					elif "huge" in checkpoint_url:
										A_				 =						torch.tensor(
										    [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]				)
					else:
										A_				 =						torch.tensor(
										    [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]]				)

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

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

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


if __name__ == "__main__":
		UpperCamelCase_					:						int				= 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.'''
		)

		UpperCamelCase_					:						List[str]				= parser.parse_args()
		convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)






"""simple docstring"""





import torch
def 							A_     ():

					'''simple docstring'''





					if torch.cuda.is_available():
										A_				 =						torch.cuda.device_count()
					else:
										A_				 =						0
					print(f'Successfully ran on {num_gpus} GPUs'				)


if __name__ == "__main__":
		main()




