





"""simple docstring"""




import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Tuple					) ->str:






	'''simple docstring'''






	if "cls_token" in name:
		a      :		Optional[Any]	=				name.replace("cls_token"    ,       "vit.embeddings.cls_token"					)
	if "mask_token" in name:
		a      :		Tuple	=				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      :		Optional[int]	=				name.replace("pos_embed"    ,       "vit.embeddings.position_embeddings"					)
	if "patch_embed.proj" in name:
		a      :		Union[str, Any]	=				name.replace("patch_embed.proj"    ,       "vit.embeddings.patch_embeddings.projection"					)
	if "patch_embed.norm" in name:
		a      :		Dict	=				name.replace("patch_embed.norm"    ,       "vit.embeddings.norm"					)
	if "decoder_blocks" in name:
		a      :		Optional[int]	=				name.replace("decoder_blocks"    ,       "decoder.decoder_layers"					)
	if "blocks" in name:
		a      :		int	=				name.replace("blocks"    ,       "vit.encoder.layer"					)
	if "attn.proj" in name:
		a      :		Optional[Any]	=				name.replace("attn.proj"    ,       "attention.output.dense"					)
	if "attn" in name:
		a      :		Optional[Any]	=				name.replace("attn"    ,       "attention.self"					)
	if "norm1" in name:
		a      :		Dict	=				name.replace("norm1"    ,       "layernorm_before"					)
	if "norm2" in name:
		a      :		Union[str, Any]	=				name.replace("norm2"    ,       "layernorm_after"					)
	if "mlp.fc1" in name:
		a      :		List[Any]	=				name.replace("mlp.fc1"    ,       "intermediate.dense"					)
	if "mlp.fc2" in name:
		a      :		Optional[Any]	=				name.replace("mlp.fc2"    ,       "output.dense"					)
	if "decoder_embed" in name:
		a      :		Tuple	=				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      :		List[str]	=				name.replace("norm.bias"    ,       "vit.layernorm.bias"					)

	return name






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    List[str]    ,       _lowercase						:    Any					) ->Tuple:






	'''simple docstring'''






	for key in orig_state_dict.copy().keys():
		a      :		Tuple	=				orig_state_dict.pop(_lowercase					)

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

		else:
			a      :		Optional[int]	=				val

	return orig_state_dict






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Tuple    ,       _lowercase						:    List[str]					) ->Any:






	'''simple docstring'''






	a      :		Any	=				ViTMAEConfig()
	if "large" in checkpoint_url:
		a      :		Optional[Any]	=				1024
		a      :		Optional[Any]	=				4096
		a      :		Any	=				24
		a      :		Union[str, Any]	=				16
	elif "huge" in checkpoint_url:
		a      :		Optional[int]	=				14
		a      :		Union[str, Any]	=				1280
		a      :		str	=				5120
		a      :		Tuple	=				32
		a      :		Union[str, Any]	=				16

	a      :		Optional[Any]	=				ViTMAEForPreTraining(_lowercase					)

	a      :		Tuple	=				torch.hub.load_state_dict_from_url(_lowercase    ,       map_location="cpu"					)["model"]

	a      :		Dict	=				ViTMAEImageProcessor(size=config.image_size					)

	a      :		Optional[int]	=				convert_state_dict(_lowercase    ,       _lowercase					)

	model.load_state_dict(_lowercase					)
	model.eval()

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

	a      :		Any	=				Image.open(requests.get(_lowercase    ,       stream=_lowercase					).raw					)
	a      :		int	=				ViTMAEImageProcessor(size=config.image_size					)
	a      :		List[str]	=				image_processor(images=_lowercase    ,       return_tensors="pt"					)

	# forward pass
	torch.manual_seed(2					)
	a      :		List[Any]	=				model(**_lowercase					)
	a      :		Optional[int]	=				outputs.logits

	if "large" in checkpoint_url:
		a      :		List[Any]	=				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      :		int	=				torch.tensor(
		    [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]					)
	else:
		a      :		Optional[int]	=				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]    ,       _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__":
		a						: Tuple     	=			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.'''
		)

		a						: Dict     	=			parser.parse_args()
		convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)









"""simple docstring"""




from decimal import Decimal, getcontext
from math import ceil, factorial






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    int					) ->str:






	'''simple docstring'''






	if not isinstance(_lowercase    ,       _lowercase					):
		raise TypeError("Undefined for non-integers"					)
	elif precision < 1:
		raise ValueError("Undefined for non-natural numbers"					)

	a      :		Tuple	=				precision
	a      :		str	=				ceil(precision / 14					)
	a      :		List[Any]	=				42_6880 * Decimal(1_0005					).sqrt()
	a      :		Union[str, Any]	=				1
	a      :		Dict	=				1359_1409
	a      :		Optional[int]	=				Decimal(_lowercase					)
	for k in range(1    ,       _lowercase					):
		a      :		int	=				factorial(6 * k					) // (factorial(3 * k					) * factorial(_lowercase					) ** 3)
		linear_term += 5_4514_0134
		exponential_term *= -26_2537_4126_4076_8000
		partial_sum += Decimal(multinomial_term * linear_term					) / exponential_term
	return str(constant_term / partial_sum					)[:-1]


if __name__ == "__main__":
		a						: Optional[Any]     	=			50
		print(F'''The first {n} digits of pi is: {pi(n)}''')


