




import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor

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

							return name

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							for key in orig_state_dict.copy().keys():
														SCREAMING_SNAKE_CASE_   	=    orig_state_dict.pop(_lowerCAmelCase     )

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

														else:
																					SCREAMING_SNAKE_CASE_   	=    val

							return orig_state_dict

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    ViTMAEConfig()
							if "large" in checkpoint_url:
														SCREAMING_SNAKE_CASE_   	=    1_0_2_4
														SCREAMING_SNAKE_CASE_   	=    4_0_9_6
														SCREAMING_SNAKE_CASE_   	=    2_4
														SCREAMING_SNAKE_CASE_   	=    1_6
							elif "huge" in checkpoint_url:
														SCREAMING_SNAKE_CASE_   	=    1_4
														SCREAMING_SNAKE_CASE_   	=    1_2_8_0
														SCREAMING_SNAKE_CASE_   	=    5_1_2_0
														SCREAMING_SNAKE_CASE_   	=    3_2
														SCREAMING_SNAKE_CASE_   	=    1_6

							SCREAMING_SNAKE_CASE_   	=    ViTMAEForPreTraining(_lowerCAmelCase     )

							SCREAMING_SNAKE_CASE_   	=    torch.hub.load_state_dict_from_url(_lowerCAmelCase  ,    map_location='''cpu'''     )['''model''']

							SCREAMING_SNAKE_CASE_   	=    ViTMAEImageProcessor(size=config.image_size     )

							SCREAMING_SNAKE_CASE_   	=    convert_state_dict(_lowerCAmelCase  ,    _lowerCAmelCase     )

							model.load_state_dict(_lowerCAmelCase     )
							model.eval()

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

							SCREAMING_SNAKE_CASE_   	=    Image.open(requests.get(_lowerCAmelCase  ,    stream=_lowerCAmelCase     ).raw     )
							SCREAMING_SNAKE_CASE_   	=    ViTMAEImageProcessor(size=config.image_size     )
							SCREAMING_SNAKE_CASE_   	=    image_processor(images=_lowerCAmelCase  ,    return_tensors='''pt'''     )

							# forward pass
							torch.manual_seed(2     )
							SCREAMING_SNAKE_CASE_   	=    model(**_lowerCAmelCase     )
							SCREAMING_SNAKE_CASE_   	=    outputs.logits

							if "large" in checkpoint_url:
														SCREAMING_SNAKE_CASE_   	=    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:
														SCREAMING_SNAKE_CASE_   	=    torch.tensor(
														    [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]     )
							else:
														SCREAMING_SNAKE_CASE_   	=    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]  ,    _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__":
			__SCREAMING_SNAKE_CASE 						=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."""
			)

			__SCREAMING_SNAKE_CASE 						=parser.parse_args()
			convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)








from __future__ import annotations

from math import pi

# Define the Reduced Planck Constant ℏ (H bar), speed of light C, value of
# Pi and the function
__SCREAMING_SNAKE_CASE 						=1.0_5_4_5_7_1_8_1_7e-3_4  # unit of ℏ : J * s

__SCREAMING_SNAKE_CASE 						=3e8  # unit of c : m * s^-1

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase     ):

							if (force, area, distance).count(0     ) != 1:
														raise ValueError('''One and only one argument must be 0'''     )
							if force < 0:
														raise ValueError('''Magnitude of force can not be negative'''     )
							if distance < 0:
														raise ValueError('''Distance can not be negative'''     )
							if area < 0:
														raise ValueError('''Area can not be negative'''     )
							if force == 0:
														SCREAMING_SNAKE_CASE_   	=    (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (
														    2_4_0 * (distance) ** 4
														)
														return {"force": force}
							elif area == 0:
														SCREAMING_SNAKE_CASE_   	=    (2_4_0 * force * (distance) ** 4) / (
														    REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2
														)
														return {"area": area}
							elif distance == 0:
														SCREAMING_SNAKE_CASE_   	=    (
														    (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (2_4_0 * force)
														) ** (1 / 4)
														return {"distance": distance}
							raise ValueError('''One and only one argument must be 0'''     )


# Run doctest
if __name__ == "__main__":
			import doctest

			doctest.testmod()


